?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / dev / ic / aic79xx.c
blob39f80e2d515034483eea307dfa6213d9c6dc22a3
1 /* $NetBSD: aic79xx.c,v 1.43 2009/09/02 17:08:12 tsutsui Exp $ */
2
3 /*
4 * Core routines and tables shareable across OS platforms.
5 *
6 * Copyright (c) 1994-2002 Justin T. Gibbs.
7 * Copyright (c) 2000-2003 Adaptec Inc.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions, and the following disclaimer,
15 * without modification.
16 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
17 * substantially similar to the "NO WARRANTY" disclaimer below
18 * ("Disclaimer") and any redistribution must be conditioned upon
19 * including a substantially similar Disclaimer requirement for further
20 * binary redistribution.
21 * 3. Neither the names of the above-listed copyright holders nor the names
22 * of any contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * Alternatively, this software may be distributed under the terms of the
26 * GNU General Public License ("GPL") version 2 as published by the Free
27 * Software Foundation.
28 *
29 * NO WARRANTY
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
31 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
32 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
33 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
34 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
38 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
39 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGES.
41 *
42 * Id: //depot/aic7xxx/aic7xxx/aic79xx.c#202 $
43 *
44 * $FreeBSD: src/sys/dev/aic7xxx/aic79xx.c,v 1.24 2003/06/28 04:46:54 gibbs Exp $
45 */
46 /*
47 * Ported from FreeBSD by Pascal Renauld, Network Storage Solutions, Inc.
48 * - April 2003
49 */
50
51 #include <sys/cdefs.h>
52 __KERNEL_RCSID(0, "$NetBSD: aic79xx.c,v 1.43 2009/09/02 17:08:12 tsutsui Exp $");
53
54 #include <dev/ic/aic79xx_osm.h>
55 #include <dev/ic/aic79xx_inline.h>
56 #include <dev/ic/aic7xxx_cam.h>
57
58 #include <dev/microcode/aic7xxx/aicasm.h>
59 #include <dev/microcode/aic7xxx/aicasm_insformat.h>
60
61
62 /******************************** Globals *************************************/
63 struct ahd_softc_tailq ahd_tailq = TAILQ_HEAD_INITIALIZER(ahd_tailq);
64
65 /***************************** Lookup Tables **********************************/
66 const char *ahd_chip_names[] =
67 {
68 "NONE",
69 "aic7901",
70 "aic7902",
71 "aic7901A"
72 };
73
74 /*
75 * Hardware error codes.
76 */
77 struct ahd_hard_error_entry {
78 uint8_t errno;
79 const char *errmesg;
80 };
81
82 static struct ahd_hard_error_entry ahd_hard_errors[] = {
83 { DSCTMOUT, "Discard Timer has timed out" },
84 { ILLOPCODE, "Illegal Opcode in sequencer program" },
85 { SQPARERR, "Sequencer Parity Error" },
86 { DPARERR, "Data-path Parity Error" },
87 { MPARERR, "Scratch or SCB Memory Parity Error" },
88 { CIOPARERR, "CIOBUS Parity Error" },
89 };
90 static const u_int num_errors = NUM_ELEMENTS(ahd_hard_errors);
91
92 static struct ahd_phase_table_entry ahd_phase_table[] =
93 {
94 { P_DATAOUT, MSG_NOOP, "in Data-out phase" },
95 { P_DATAIN, MSG_INITIATOR_DET_ERR, "in Data-in phase" },
96 { P_DATAOUT_DT, MSG_NOOP, "in DT Data-out phase" },
97 { P_DATAIN_DT, MSG_INITIATOR_DET_ERR, "in DT Data-in phase" },
98 { P_COMMAND, MSG_NOOP, "in Command phase" },
99 { P_MESGOUT, MSG_NOOP, "in Message-out phase" },
100 { P_STATUS, MSG_INITIATOR_DET_ERR, "in Status phase" },
101 { P_MESGIN, MSG_PARITY_ERROR, "in Message-in phase" },
102 { P_BUSFREE, MSG_NOOP, "while idle" },
103 { 0, MSG_NOOP, "in unknown phase" }
104 };
105
106 /*
107 * In most cases we only wish to itterate over real phases, so
108 * exclude the last element from the count.
109 */
110 static const u_int num_phases = NUM_ELEMENTS(ahd_phase_table) - 1;
111
112 /* Our Sequencer Program */
113 #include <dev/microcode/aic7xxx/aic79xx_seq.h>
114
115 /**************************** Function Declarations ***************************/
116 static void ahd_handle_transmission_error(struct ahd_softc *ahd);
117 static void ahd_handle_lqiphase_error(struct ahd_softc *ahd,
118 u_int lqistat1);
119 static int ahd_handle_pkt_busfree(struct ahd_softc *ahd,
120 u_int busfreetime);
121 static int ahd_handle_nonpkt_busfree(struct ahd_softc *ahd);
122 static void ahd_handle_proto_violation(struct ahd_softc *ahd);
123 static void ahd_force_renegotiation(struct ahd_softc *ahd,
124 struct ahd_devinfo *devinfo);
125
126 static struct ahd_tmode_tstate*
127 ahd_alloc_tstate(struct ahd_softc *ahd,
128 u_int scsi_id, char channel);
129 #ifdef AHD_TARGET_MODE
130 static void ahd_free_tstate(struct ahd_softc *ahd,
131 u_int scsi_id, char channel, int force);
132 #endif
133 static void ahd_devlimited_syncrate(struct ahd_softc *ahd,
134 struct ahd_initiator_tinfo *,
135 u_int *period,
136 u_int *ppr_options,
137 role_t role);
138 static void ahd_update_neg_table(struct ahd_softc *ahd,
139 struct ahd_devinfo *devinfo,
140 struct ahd_transinfo *tinfo);
141 static void ahd_update_pending_scbs(struct ahd_softc *ahd);
142 static void ahd_fetch_devinfo(struct ahd_softc *ahd,
143 struct ahd_devinfo *devinfo);
144 static void ahd_scb_devinfo(struct ahd_softc *ahd,
145 struct ahd_devinfo *devinfo,
146 struct scb *scb);
147 static void ahd_setup_initiator_msgout(struct ahd_softc *ahd,
148 struct ahd_devinfo *devinfo,
149 struct scb *scb);
150 static void ahd_build_transfer_msg(struct ahd_softc *ahd,
151 struct ahd_devinfo *devinfo);
152 static void ahd_construct_sdtr(struct ahd_softc *ahd,
153 struct ahd_devinfo *devinfo,
154 u_int period, u_int offset);
155 static void ahd_construct_wdtr(struct ahd_softc *ahd,
156 struct ahd_devinfo *devinfo,
157 u_int bus_width);
158 static void ahd_construct_ppr(struct ahd_softc *ahd,
159 struct ahd_devinfo *devinfo,
160 u_int period, u_int offset,
161 u_int bus_width, u_int ppr_options);
162 static void ahd_clear_msg_state(struct ahd_softc *ahd);
163 static void ahd_handle_message_phase(struct ahd_softc *ahd);
164 typedef enum {
165 AHDMSG_1B,
166 AHDMSG_2B,
167 AHDMSG_EXT
168 } ahd_msgtype;
169 static int ahd_sent_msg(struct ahd_softc *ahd, ahd_msgtype type,
170 u_int msgval, int full);
171 static int ahd_parse_msg(struct ahd_softc *ahd,
172 struct ahd_devinfo *devinfo);
173 static int ahd_handle_msg_reject(struct ahd_softc *ahd,
174 struct ahd_devinfo *devinfo);
175 static void ahd_handle_ign_wide_residue(struct ahd_softc *ahd,
176 struct ahd_devinfo *devinfo);
177 static void ahd_reinitialize_dataptrs(struct ahd_softc *ahd);
178 static void ahd_handle_devreset(struct ahd_softc *ahd,
179 struct ahd_devinfo *devinfo,
180 u_int lun, cam_status status,
181 const char *message,
182 int verbose_level);
183 #if AHD_TARGET_MODE
184 static void ahd_setup_target_msgin(struct ahd_softc *ahd,
185 struct ahd_devinfo *devinfo,
186 struct scb *scb);
187 #endif
188
189 static u_int ahd_sglist_size(struct ahd_softc *ahd);
190 static u_int ahd_sglist_allocsize(struct ahd_softc *ahd);
191 static void ahd_initialize_hscbs(struct ahd_softc *ahd);
192 static int ahd_init_scbdata(struct ahd_softc *ahd);
193 static void ahd_fini_scbdata(struct ahd_softc *ahd);
194 static void ahd_setup_iocell_workaround(struct ahd_softc *ahd);
195 static void ahd_iocell_first_selection(struct ahd_softc *ahd);
196 static void ahd_add_col_list(struct ahd_softc *ahd,
197 struct scb *scb, u_int col_idx);
198 static void ahd_rem_col_list(struct ahd_softc *ahd,
199 struct scb *scb);
200 static void ahd_chip_init(struct ahd_softc *ahd);
201 static void ahd_qinfifo_requeue(struct ahd_softc *ahd,
202 struct scb *prev_scb,
203 struct scb *scb);
204 static int ahd_qinfifo_count(struct ahd_softc *ahd);
205 static int ahd_search_scb_list(struct ahd_softc *ahd, int target,
206 char channel, int lun, u_int tag,
207 role_t role, uint32_t status,
208 ahd_search_action action,
209 u_int *list_head, u_int tid);
210 static void ahd_stitch_tid_list(struct ahd_softc *ahd,
211 u_int tid_prev, u_int tid_cur,
212 u_int tid_next);
213 static void ahd_add_scb_to_free_list(struct ahd_softc *ahd,
214 u_int scbid);
215 static u_int ahd_rem_wscb(struct ahd_softc *ahd, u_int scbid,
216 u_int prev, u_int next, u_int tid);
217 static void ahd_reset_current_bus(struct ahd_softc *ahd);
218 static ahd_callback_t ahd_reset_poll;
219 static ahd_callback_t ahd_stat_timer;
220 #ifdef AHD_DUMP_SEQ
221 static void ahd_dumpseq(struct ahd_softc *ahd);
222 #endif
223 static void ahd_loadseq(struct ahd_softc *ahd);
224 static int ahd_check_patch(struct ahd_softc *ahd,
225 struct patch **start_patch,
226 u_int start_instr, u_int *skip_addr);
227 static u_int ahd_resolve_seqaddr(struct ahd_softc *ahd,
228 u_int address);
229 static void ahd_download_instr(struct ahd_softc *ahd,
230 u_int instrptr, uint8_t *dconsts);
231 static int ahd_probe_stack_size(struct ahd_softc *ahd);
232 static int ahd_scb_active_in_fifo(struct ahd_softc *ahd,
233 struct scb *scb);
234 static void ahd_run_data_fifo(struct ahd_softc *ahd,
235 struct scb *scb);
236
237 #ifdef AHD_TARGET_MODE
238 static void ahd_queue_lstate_event(struct ahd_softc *ahd,
239 struct ahd_tmode_lstate *lstate,
240 u_int initiator_id,
241 u_int event_type,
242 u_int event_arg);
243 static void ahd_update_scsiid(struct ahd_softc *ahd,
244 u_int targid_mask);
245 static int ahd_handle_target_cmd(struct ahd_softc *ahd,
246 struct target_cmd *cmd);
247 #endif
248
249 /************************** Added for porting to NetBSD ***********************/
250 static int ahd_createdmamem(bus_dma_tag_t tag,
251 int size,
252 int flags,
253 bus_dmamap_t *mapp,
254 void **vaddr,
255 bus_addr_t *baddr,
256 bus_dma_segment_t *seg,
257 int *nseg,
258 const char *myname, const char *what);
259
260 static void ahd_freedmamem(bus_dma_tag_t tag,
261 int size,
262 bus_dmamap_t map,
263 void *vaddr,
264 bus_dma_segment_t *seg,
265 int nseg);
266
267 /******************************** Private Inlines *****************************/
268 static inline void ahd_assert_atn(struct ahd_softc *ahd);
269 static inline int ahd_currently_packetized(struct ahd_softc *ahd);
270 static inline int ahd_set_active_fifo(struct ahd_softc *ahd);
271
272 static inline void
273 ahd_assert_atn(struct ahd_softc *ahd)
274 {
275 ahd_outb(ahd, SCSISIGO, ATNO);
276 }
277
278 /*
279 * Determine if the current connection has a packetized
280 * agreement. This does not necessarily mean that we
281 * are currently in a packetized transfer. We could
282 * just as easily be sending or receiving a message.
283 */
284 static inline int
285 ahd_currently_packetized(struct ahd_softc *ahd)
286 {
287 ahd_mode_state saved_modes;
288 int packetized;
289
290 saved_modes = ahd_save_modes(ahd);
291 if ((ahd->bugs & AHD_PKTIZED_STATUS_BUG) != 0) {
292 /*
293 * The packetized bit refers to the last
294 * connection, not the current one. Check
295 * for non-zero LQISTATE instead.
296 */
297 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
298 packetized = ahd_inb(ahd, LQISTATE) != 0;
299 } else {
300 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
301 packetized = ahd_inb(ahd, LQISTAT2) & PACKETIZED;
302 }
303 ahd_restore_modes(ahd, saved_modes);
304 return (packetized);
305 }
306
307 static inline int
308 ahd_set_active_fifo(struct ahd_softc *ahd)
309 {
310 u_int active_fifo;
311
312 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
313 active_fifo = ahd_inb(ahd, DFFSTAT) & CURRFIFO;
314 switch (active_fifo) {
315 case 0:
316 case 1:
317 ahd_set_modes(ahd, active_fifo, active_fifo);
318 return (1);
319 default:
320 return (0);
321 }
322 }
323
324 /************************* Sequencer Execution Control ************************/
325 /*
326 * Restart the sequencer program from address zero
327 */
328 void
329 ahd_restart(struct ahd_softc *ahd)
330 {
331
332 ahd_pause(ahd);
333
334 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
335
336 /* No more pending messages */
337 ahd_clear_msg_state(ahd);
338 ahd_outb(ahd, SCSISIGO, 0); /* De-assert BSY */
339 ahd_outb(ahd, MSG_OUT, MSG_NOOP); /* No message to send */
340 ahd_outb(ahd, SXFRCTL1, ahd_inb(ahd, SXFRCTL1) & ~BITBUCKET);
341 ahd_outb(ahd, SEQINTCTL, 0);
342 ahd_outb(ahd, LASTPHASE, P_BUSFREE);
343 ahd_outb(ahd, SEQ_FLAGS, 0);
344 ahd_outb(ahd, SAVED_SCSIID, 0xFF);
345 ahd_outb(ahd, SAVED_LUN, 0xFF);
346
347 /*
348 * Ensure that the sequencer's idea of TQINPOS
349 * matches our own. The sequencer increments TQINPOS
350 * only after it sees a DMA complete and a reset could
351 * occur before the increment leaving the kernel to believe
352 * the command arrived but the sequencer to not.
353 */
354 ahd_outb(ahd, TQINPOS, ahd->tqinfifonext);
355
356 /* Always allow reselection */
357 ahd_outb(ahd, SCSISEQ1,
358 ahd_inb(ahd, SCSISEQ_TEMPLATE) & (ENSELI|ENRSELI|ENAUTOATNP));
359 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
360 ahd_outb(ahd, SEQCTL0, FASTMODE|SEQRESET);
361 ahd_unpause(ahd);
362 }
363
364 void
365 ahd_clear_fifo(struct ahd_softc *ahd, u_int fifo)
366 {
367 ahd_mode_state saved_modes;
368
369 #ifdef AHD_DEBUG
370 if ((ahd_debug & AHD_SHOW_FIFOS) != 0)
371 printf("%s: Clearing FIFO %d\n", ahd_name(ahd), fifo);
372 #endif
373 saved_modes = ahd_save_modes(ahd);
374 ahd_set_modes(ahd, fifo, fifo);
375 ahd_outb(ahd, DFFSXFRCTL, RSTCHN|CLRSHCNT);
376 if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0)
377 ahd_outb(ahd, CCSGCTL, CCSGRESET);
378 ahd_outb(ahd, LONGJMP_ADDR + 1, INVALID_ADDR);
379 ahd_outb(ahd, SG_STATE, 0);
380 ahd_restore_modes(ahd, saved_modes);
381 }
382
383 /************************* Input/Output Queues ********************************/
384 /*
385 * Flush and completed commands that are sitting in the command
386 * complete queues down on the chip but have yet to be DMA'ed back up.
387 */
388 void
389 ahd_flush_qoutfifo(struct ahd_softc *ahd)
390 {
391 struct scb *scb;
392 ahd_mode_state saved_modes;
393 u_int saved_scbptr;
394 u_int ccscbctl;
395 u_int scbid;
396 u_int next_scbid;
397
398 saved_modes = ahd_save_modes(ahd);
399
400 /*
401 * Complete any SCBs that just finished being
402 * DMA'ed into the qoutfifo.
403 */
404 ahd_run_qoutfifo(ahd);
405
406 /*
407 * Flush the good status FIFO for compelted packetized commands.
408 */
409 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
410 saved_scbptr = ahd_get_scbptr(ahd);
411 while ((ahd_inb(ahd, LQISTAT2) & LQIGSAVAIL) != 0) {
412 u_int fifo_mode;
413 u_int i;
414
415 scbid = (ahd_inb(ahd, GSFIFO+1) << 8)
416 | ahd_inb(ahd, GSFIFO);
417 scb = ahd_lookup_scb(ahd, scbid);
418 if (scb == NULL) {
419 printf("%s: Warning - GSFIFO SCB %d invalid\n",
420 ahd_name(ahd), scbid);
421 continue;
422 }
423 /*
424 * Determine if this transaction is still active in
425 * any FIFO. If it is, we must flush that FIFO to
426 * the host before completing the command.
427 */
428 fifo_mode = 0;
429 for (i = 0; i < 2; i++) {
430 /* Toggle to the other mode. */
431 fifo_mode ^= 1;
432 ahd_set_modes(ahd, fifo_mode, fifo_mode);
433 if (ahd_scb_active_in_fifo(ahd, scb) == 0)
434 continue;
435
436 ahd_run_data_fifo(ahd, scb);
437
438 /*
439 * Clearing this transaction in this FIFO may
440 * cause a CFG4DATA for this same transaction
441 * to assert in the other FIFO. Make sure we
442 * loop one more time and check the other FIFO.
443 */
444 i = 0;
445 }
446 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
447 ahd_set_scbptr(ahd, scbid);
448 if ((ahd_inb_scbram(ahd, SCB_SGPTR) & SG_LIST_NULL) == 0
449 && ((ahd_inb_scbram(ahd, SCB_SGPTR) & SG_FULL_RESID) != 0
450 || (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR)
451 & SG_LIST_NULL) != 0)) {
452 u_int comp_head;
453
454 /*
455 * The transfer completed with a residual.
456 * Place this SCB on the complete DMA list
457 * so that we Update our in-core copy of the
458 * SCB before completing the command.
459 */
460 ahd_outb(ahd, SCB_SCSI_STATUS, 0);
461 ahd_outb(ahd, SCB_SGPTR,
462 ahd_inb_scbram(ahd, SCB_SGPTR)
463 | SG_STATUS_VALID);
464 ahd_outw(ahd, SCB_TAG, SCB_GET_TAG(scb));
465 comp_head = ahd_inw(ahd, COMPLETE_DMA_SCB_HEAD);
466 ahd_outw(ahd, SCB_NEXT_COMPLETE, comp_head);
467 if (SCBID_IS_NULL(comp_head))
468 ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD,
469 SCB_GET_TAG(scb));
470 } else
471 ahd_complete_scb(ahd, scb);
472 }
473 ahd_set_scbptr(ahd, saved_scbptr);
474
475 /*
476 * Setup for command channel portion of flush.
477 */
478 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
479
480 /*
481 * Wait for any inprogress DMA to complete and clear DMA state
482 * if this if for an SCB in the qinfifo.
483 */
484 while (((ccscbctl = ahd_inb(ahd, CCSCBCTL)) & (CCARREN|CCSCBEN)) != 0) {
485
486 if ((ccscbctl & (CCSCBDIR|CCARREN)) == (CCSCBDIR|CCARREN)) {
487 if ((ccscbctl & ARRDONE) != 0)
488 break;
489 } else if ((ccscbctl & CCSCBDONE) != 0)
490 break;
491 ahd_delay(200);
492 }
493 if ((ccscbctl & CCSCBDIR) != 0)
494 ahd_outb(ahd, CCSCBCTL, ccscbctl & ~(CCARREN|CCSCBEN));
495
496 saved_scbptr = ahd_get_scbptr(ahd);
497 /*
498 * Manually update/complete any completed SCBs that are waiting to be
499 * DMA'ed back up to the host.
500 */
501 scbid = ahd_inw(ahd, COMPLETE_DMA_SCB_HEAD);
502 while (!SCBID_IS_NULL(scbid)) {
503 uint8_t *hscb_ptr;
504 u_int i;
505
506 ahd_set_scbptr(ahd, scbid);
507 next_scbid = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
508 scb = ahd_lookup_scb(ahd, scbid);
509 if (scb == NULL) {
510 printf("%s: Warning - DMA-up and complete "
511 "SCB %d invalid\n", ahd_name(ahd), scbid);
512 continue;
513 }
514 hscb_ptr = (uint8_t *)scb->hscb;
515 for (i = 0; i < sizeof(struct hardware_scb); i++)
516 *hscb_ptr++ = ahd_inb_scbram(ahd, SCB_BASE + i);
517
518 ahd_complete_scb(ahd, scb);
519 scbid = next_scbid;
520 }
521 ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD, SCB_LIST_NULL);
522
523 scbid = ahd_inw(ahd, COMPLETE_SCB_HEAD);
524 while (!SCBID_IS_NULL(scbid)) {
525
526 ahd_set_scbptr(ahd, scbid);
527 next_scbid = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
528 scb = ahd_lookup_scb(ahd, scbid);
529 if (scb == NULL) {
530 printf("%s: Warning - Complete SCB %d invalid\n",
531 ahd_name(ahd), scbid);
532 continue;
533 }
534
535 ahd_complete_scb(ahd, scb);
536 scbid = next_scbid;
537 }
538 ahd_outw(ahd, COMPLETE_SCB_HEAD, SCB_LIST_NULL);
539
540 /*
541 * Restore state.
542 */
543 ahd_set_scbptr(ahd, saved_scbptr);
544 ahd_restore_modes(ahd, saved_modes);
545 ahd->flags |= AHD_UPDATE_PEND_CMDS;
546 }
547
548 /*
549 * Determine if an SCB for a packetized transaction
550 * is active in a FIFO.
551 */
552 static int
553 ahd_scb_active_in_fifo(struct ahd_softc *ahd, struct scb *scb)
554 {
555
556 /*
557 * The FIFO is only active for our transaction if
558 * the SCBPTR matches the SCB's ID and the firmware
559 * has installed a handler for the FIFO or we have
560 * a pending SAVEPTRS or CFG4DATA interrupt.
561 */
562 if (ahd_get_scbptr(ahd) != SCB_GET_TAG(scb)
563 || ((ahd_inb(ahd, LONGJMP_ADDR+1) & INVALID_ADDR) != 0
564 && (ahd_inb(ahd, SEQINTSRC) & (CFG4DATA|SAVEPTRS)) == 0))
565 return (0);
566
567 return (1);
568 }
569
570 /*
571 * Run a data fifo to completion for a transaction we know
572 * has completed across the SCSI bus (good status has been
573 * received). We are already set to the correct FIFO mode
574 * on entry to this routine.
575 *
576 * This function attempts to operate exactly as the firmware
577 * would when running this FIFO. Care must be taken to update
578 * this routine any time the firmware's FIFO algorithm is
579 * changed.
580 */
581 static void
582 ahd_run_data_fifo(struct ahd_softc *ahd, struct scb *scb)
583 {
584 u_int seqintsrc;
585
586 while (1) {
587 seqintsrc = ahd_inb(ahd, SEQINTSRC);
588 if ((seqintsrc & CFG4DATA) != 0) {
589 uint32_t datacnt;
590 uint32_t sgptr;
591
592 /*
593 * Clear full residual flag.
594 */
595 sgptr = ahd_inl_scbram(ahd, SCB_SGPTR) & ~SG_FULL_RESID;
596 ahd_outb(ahd, SCB_SGPTR, sgptr);
597
598 /*
599 * Load datacnt and address.
600 */
601 datacnt = ahd_inl_scbram(ahd, SCB_DATACNT);
602 if ((datacnt & AHD_DMA_LAST_SEG) != 0) {
603 sgptr |= LAST_SEG;
604 ahd_outb(ahd, SG_STATE, 0);
605 } else
606 ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
607 ahd_outq(ahd, HADDR, ahd_inq_scbram(ahd, SCB_DATAPTR));
608 ahd_outl(ahd, HCNT, datacnt & AHD_SG_LEN_MASK);
609 ahd_outb(ahd, SG_CACHE_PRE, sgptr);
610 ahd_outb(ahd, DFCNTRL, PRELOADEN|SCSIEN|HDMAEN);
611
612 /*
613 * Initialize Residual Fields.
614 */
615 ahd_outb(ahd, SCB_RESIDUAL_DATACNT+3, datacnt >> 24);
616 ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr & SG_PTR_MASK);
617
618 /*
619 * Mark the SCB as having a FIFO in use.
620 */
621 ahd_outb(ahd, SCB_FIFO_USE_COUNT,
622 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) + 1);
623
624 /*
625 * Install a "fake" handler for this FIFO.
626 */
627 ahd_outw(ahd, LONGJMP_ADDR, 0);
628
629 /*
630 * Notify the hardware that we have satisfied
631 * this sequencer interrupt.
632 */
633 ahd_outb(ahd, CLRSEQINTSRC, CLRCFG4DATA);
634 } else if ((seqintsrc & SAVEPTRS) != 0) {
635 uint32_t sgptr;
636 uint32_t resid;
637
638 if ((ahd_inb(ahd, LONGJMP_ADDR+1)&INVALID_ADDR) != 0) {
639 /*
640 * Snapshot Save Pointers. Clear
641 * the snapshot and continue.
642 */
643 ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
644 continue;
645 }
646
647 /*
648 * Disable S/G fetch so the DMA engine
649 * is available to future users.
650 */
651 if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0)
652 ahd_outb(ahd, CCSGCTL, 0);
653 ahd_outb(ahd, SG_STATE, 0);
654
655 /*
656 * Flush the data FIFO. Strickly only
657 * necessary for Rev A parts.
658 */
659 ahd_outb(ahd, DFCNTRL,
660 ahd_inb(ahd, DFCNTRL) | FIFOFLUSH);
661
662 /*
663 * Calculate residual.
664 */
665 sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
666 resid = ahd_inl(ahd, SHCNT);
667 resid |=
668 ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT+3) << 24;
669 ahd_outl(ahd, SCB_RESIDUAL_DATACNT, resid);
670 if ((ahd_inb(ahd, SG_CACHE_SHADOW) & LAST_SEG) == 0) {
671 /*
672 * Must back up to the correct S/G element.
673 * Typically this just means resetting our
674 * low byte to the offset in the SG_CACHE,
675 * but if we wrapped, we have to correct
676 * the other bytes of the sgptr too.
677 */
678 if ((ahd_inb(ahd, SG_CACHE_SHADOW) & 0x80) != 0
679 && (sgptr & 0x80) == 0)
680 sgptr -= 0x100;
681 sgptr &= ~0xFF;
682 sgptr |= ahd_inb(ahd, SG_CACHE_SHADOW)
683 & SG_ADDR_MASK;
684 ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr);
685 ahd_outb(ahd, SCB_RESIDUAL_DATACNT + 3, 0);
686 } else if ((resid & AHD_SG_LEN_MASK) == 0) {
687 ahd_outb(ahd, SCB_RESIDUAL_SGPTR,
688 sgptr | SG_LIST_NULL);
689 }
690 /*
691 * Save Pointers.
692 */
693 ahd_outq(ahd, SCB_DATAPTR, ahd_inq(ahd, SHADDR));
694 ahd_outl(ahd, SCB_DATACNT, resid);
695 ahd_outl(ahd, SCB_SGPTR, sgptr);
696 ahd_outb(ahd, CLRSEQINTSRC, CLRSAVEPTRS);
697 ahd_outb(ahd, SEQIMODE,
698 ahd_inb(ahd, SEQIMODE) | ENSAVEPTRS);
699 /*
700 * If the data is to the SCSI bus, we are
701 * done, otherwise wait for FIFOEMP.
702 */
703 if ((ahd_inb(ahd, DFCNTRL) & DIRECTION) != 0)
704 break;
705 } else if ((ahd_inb(ahd, SG_STATE) & LOADING_NEEDED) != 0) {
706 uint32_t sgptr;
707 uint64_t data_addr;
708 uint32_t data_len;
709 u_int dfcntrl;
710
711 /*
712 * Disable S/G fetch so the DMA engine
713 * is available to future users.
714 */
715 if ((ahd_inb(ahd, SG_STATE) & FETCH_INPROG) != 0) {
716 ahd_outb(ahd, CCSGCTL, 0);
717 ahd_outb(ahd, SG_STATE, LOADING_NEEDED);
718 }
719
720 /*
721 * Wait for the DMA engine to notice that the
722 * host transfer is enabled and that there is
723 * space in the S/G FIFO for new segments before
724 * loading more segments.
725 */
726 if ((ahd_inb(ahd, DFSTATUS) & PRELOAD_AVAIL) == 0)
727 continue;
728 if ((ahd_inb(ahd, DFCNTRL) & HDMAENACK) == 0)
729 continue;
730
731 /*
732 * Determine the offset of the next S/G
733 * element to load.
734 */
735 sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
736 sgptr &= SG_PTR_MASK;
737 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
738 struct ahd_dma64_seg *sg;
739
740 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
741 data_addr = sg->addr;
742 data_len = sg->len;
743 sgptr += sizeof(*sg);
744 } else {
745 struct ahd_dma_seg *sg;
746
747 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
748 data_addr = sg->len & AHD_SG_HIGH_ADDR_MASK;
749 data_addr <<= 8;
750 data_addr |= sg->addr;
751 data_len = sg->len;
752 sgptr += sizeof(*sg);
753 }
754
755 /*
756 * Update residual information.
757 */
758 ahd_outb(ahd, SCB_RESIDUAL_DATACNT+3, data_len >> 24);
759 ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr);
760
761 /*
762 * Load the S/G.
763 */
764 if (data_len & AHD_DMA_LAST_SEG) {
765 sgptr |= LAST_SEG;
766 ahd_outb(ahd, SG_STATE, 0);
767 }
768 ahd_outq(ahd, HADDR, data_addr);
769 ahd_outl(ahd, HCNT, data_len & AHD_SG_LEN_MASK);
770 ahd_outb(ahd, SG_CACHE_PRE, sgptr & 0xFF);
771
772 /*
773 * Advertise the segment to the hardware.
774 */
775 dfcntrl = ahd_inb(ahd, DFCNTRL)|PRELOADEN|HDMAEN;
776 if ((ahd->features & AHD_NEW_DFCNTRL_OPTS)!=0) {
777 /*
778 * Use SCSIENWRDIS so that SCSIEN
779 * is never modified by this
780 * operation.
781 */
782 dfcntrl |= SCSIENWRDIS;
783 }
784 ahd_outb(ahd, DFCNTRL, dfcntrl);
785 } else if ((ahd_inb(ahd, SG_CACHE_SHADOW)
786 & LAST_SEG_DONE) != 0) {
787
788 /*
789 * Transfer completed to the end of SG list
790 * and has flushed to the host.
791 */
792 ahd_outb(ahd, SCB_SGPTR,
793 ahd_inb_scbram(ahd, SCB_SGPTR) | SG_LIST_NULL);
794 break;
795 } else if ((ahd_inb(ahd, DFSTATUS) & FIFOEMP) != 0) {
796 break;
797 }
798 ahd_delay(200);
799 }
800 /*
801 * Clear any handler for this FIFO, decrement
802 * the FIFO use count for the SCB, and release
803 * the FIFO.
804 */
805 ahd_outb(ahd, LONGJMP_ADDR + 1, INVALID_ADDR);
806 ahd_outb(ahd, SCB_FIFO_USE_COUNT,
807 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT) - 1);
808 ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
809 }
810
811 void
812 ahd_run_qoutfifo(struct ahd_softc *ahd)
813 {
814 struct scb *scb;
815 u_int scb_index;
816
817 if ((ahd->flags & AHD_RUNNING_QOUTFIFO) != 0)
818 panic("ahd_run_qoutfifo recursion");
819 ahd->flags |= AHD_RUNNING_QOUTFIFO;
820 ahd_sync_qoutfifo(ahd, BUS_DMASYNC_POSTREAD);
821 while ((ahd->qoutfifo[ahd->qoutfifonext]
822 & QOUTFIFO_ENTRY_VALID_LE) == ahd->qoutfifonext_valid_tag) {
823
824 scb_index = ahd_le16toh(ahd->qoutfifo[ahd->qoutfifonext]
825 & ~QOUTFIFO_ENTRY_VALID_LE);
826 scb = ahd_lookup_scb(ahd, scb_index);
827 if (scb == NULL) {
828 printf("%s: WARNING no command for scb %d "
829 "(cmdcmplt)\nQOUTPOS = %d\n",
830 ahd_name(ahd), scb_index,
831 ahd->qoutfifonext);
832 ahd_dump_card_state(ahd);
833 } else
834 ahd_complete_scb(ahd, scb);
835
836 ahd->qoutfifonext = (ahd->qoutfifonext+1) & (AHD_QOUT_SIZE-1);
837 if (ahd->qoutfifonext == 0)
838 ahd->qoutfifonext_valid_tag ^= QOUTFIFO_ENTRY_VALID_LE;
839 }
840 ahd->flags &= ~AHD_RUNNING_QOUTFIFO;
841 }
842
843 /************************* Interrupt Handling *********************************/
844 void
845 ahd_handle_hwerrint(struct ahd_softc *ahd)
846 {
847 /*
848 * Some catastrophic hardware error has occurred.
849 * Print it for the user and disable the controller.
850 */
851 int i;
852 int error;
853
854 error = ahd_inb(ahd, ERROR);
855 for (i = 0; i < num_errors; i++) {
856 if ((error & ahd_hard_errors[i].errno) != 0)
857 printf("%s: hwerrint, %s\n",
858 ahd_name(ahd), ahd_hard_errors[i].errmesg);
859 }
860
861 ahd_dump_card_state(ahd);
862 panic("BRKADRINT");
863
864 /* Tell everyone that this HBA is no longer available */
865 ahd_abort_scbs(ahd, CAM_TARGET_WILDCARD, ALL_CHANNELS,
866 CAM_LUN_WILDCARD, SCB_LIST_NULL, ROLE_UNKNOWN,
867 CAM_NO_HBA);
868
869 /* Tell the system that this controller has gone away. */
870 ahd_free(ahd);
871 }
872
873 void
874 ahd_handle_seqint(struct ahd_softc *ahd, u_int intstat)
875 {
876 u_int seqintcode;
877
878 /*
879 * Save the sequencer interrupt code and clear the SEQINT
880 * bit. We will unpause the sequencer, if appropriate,
881 * after servicing the request.
882 */
883 seqintcode = ahd_inb(ahd, SEQINTCODE);
884 ahd_outb(ahd, CLRINT, CLRSEQINT);
885 if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
886 /*
887 * Unpause the sequencer and let it clear
888 * SEQINT by writing NO_SEQINT to it. This
889 * will cause the sequencer to be paused again,
890 * which is the expected state of this routine.
891 */
892 ahd_unpause(ahd);
893 while (!ahd_is_paused(ahd))
894 ;
895 ahd_outb(ahd, CLRINT, CLRSEQINT);
896 }
897 ahd_update_modes(ahd);
898 #ifdef AHD_DEBUG
899 if ((ahd_debug & AHD_SHOW_MISC) != 0)
900 printf("%s: Handle Seqint Called for code %d\n",
901 ahd_name(ahd), seqintcode);
902 #endif
903 switch (seqintcode) {
904 case BAD_SCB_STATUS:
905 {
906 struct scb *scb;
907 u_int scbid;
908 int cmds_pending;
909
910 scbid = ahd_get_scbptr(ahd);
911 scb = ahd_lookup_scb(ahd, scbid);
912 if (scb != NULL) {
913 ahd_complete_scb(ahd, scb);
914 } else {
915 printf("%s: WARNING no command for scb %d "
916 "(bad status)\n", ahd_name(ahd), scbid);
917 ahd_dump_card_state(ahd);
918 }
919 cmds_pending = ahd_inw(ahd, CMDS_PENDING);
920 if (cmds_pending > 0)
921 ahd_outw(ahd, CMDS_PENDING, cmds_pending - 1);
922 break;
923 }
924 case ENTERING_NONPACK:
925 {
926 struct scb *scb;
927 u_int scbid;
928
929 AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
930 ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
931 scbid = ahd_get_scbptr(ahd);
932 scb = ahd_lookup_scb(ahd, scbid);
933 if (scb == NULL) {
934 /*
935 * Somehow need to know if this
936 * is from a selection or reselection.
937 * From that, we can determine target
938 * ID so we at least have an I_T nexus.
939 */
940 } else {
941 ahd_outb(ahd, SAVED_SCSIID, scb->hscb->scsiid);
942 ahd_outb(ahd, SAVED_LUN, scb->hscb->lun);
943 ahd_outb(ahd, SEQ_FLAGS, 0x0);
944 }
945 if ((ahd_inb(ahd, LQISTAT2) & LQIPHASE_OUTPKT) != 0
946 && (ahd_inb(ahd, SCSISIGO) & ATNO) != 0) {
947 /*
948 * Phase change after read stream with
949 * CRC error with P0 asserted on last
950 * packet.
951 */
952 #ifdef AHD_DEBUG
953 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0)
954 printf("%s: Assuming LQIPHASE_NLQ with "
955 "P0 assertion\n", ahd_name(ahd));
956 #endif
957 }
958 #ifdef AHD_DEBUG
959 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0)
960 printf("%s: Entering NONPACK\n", ahd_name(ahd));
961 #endif
962 break;
963 }
964 case INVALID_SEQINT:
965 printf("%s: Invalid Sequencer interrupt occurred.\n",
966 ahd_name(ahd));
967 ahd_dump_card_state(ahd);
968 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
969 break;
970 case STATUS_OVERRUN:
971 {
972 struct scb *scb;
973 u_int scbid;
974
975 scbid = ahd_get_scbptr(ahd);
976 scb = ahd_lookup_scb(ahd, scbid);
977 if (scb != NULL)
978 ahd_print_path(ahd, scb);
979 else
980 printf("%s: ", ahd_name(ahd));
981 printf("SCB %d Packetized Status Overrun", scbid);
982 ahd_dump_card_state(ahd);
983 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
984 break;
985 }
986 case CFG4ISTAT_INTR:
987 {
988 struct scb *scb;
989 u_int scbid;
990
991 scbid = ahd_get_scbptr(ahd);
992 scb = ahd_lookup_scb(ahd, scbid);
993 if (scb == NULL) {
994 ahd_dump_card_state(ahd);
995 printf("CFG4ISTAT: Free SCB %d referenced", scbid);
996 panic("For safety");
997 }
998 ahd_outq(ahd, HADDR, scb->sense_busaddr);
999 ahd_outw(ahd, HCNT, AHD_SENSE_BUFSIZE);
1000 ahd_outb(ahd, HCNT + 2, 0);
1001 ahd_outb(ahd, SG_CACHE_PRE, SG_LAST_SEG);
1002 ahd_outb(ahd, DFCNTRL, PRELOADEN|SCSIEN|HDMAEN);
1003 break;
1004 }
1005 case ILLEGAL_PHASE:
1006 {
1007 u_int bus_phase;
1008
1009 bus_phase = ahd_inb(ahd, SCSISIGI) & PHASE_MASK;
1010 printf("%s: ILLEGAL_PHASE 0x%x\n",
1011 ahd_name(ahd), bus_phase);
1012
1013 switch (bus_phase) {
1014 case P_DATAOUT:
1015 case P_DATAIN:
1016 case P_DATAOUT_DT:
1017 case P_DATAIN_DT:
1018 case P_MESGOUT:
1019 case P_STATUS:
1020 case P_MESGIN:
1021 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1022 printf("%s: Issued Bus Reset.\n", ahd_name(ahd));
1023 break;
1024 case P_COMMAND:
1025 {
1026 struct ahd_devinfo devinfo;
1027 struct scb *scb;
1028 struct ahd_initiator_tinfo *targ_info;
1029 struct ahd_tmode_tstate *tstate;
1030 struct ahd_transinfo *tinfo;
1031 u_int scbid;
1032
1033 /*
1034 * If a target takes us into the command phase
1035 * assume that it has been externally reset and
1036 * has thus lost our previous packetized negotiation
1037 * agreement. Since we have not sent an identify
1038 * message and may not have fully qualified the
1039 * connection, we change our command to TUR, assert
1040 * ATN and ABORT the task when we go to message in
1041 * phase. The OSM will see the REQUEUE_REQUEST
1042 * status and retry the command.
1043 */
1044 scbid = ahd_get_scbptr(ahd);
1045 scb = ahd_lookup_scb(ahd, scbid);
1046 if (scb == NULL) {
1047 printf("Invalid phase with no valid SCB. "
1048 "Resetting bus.\n");
1049 ahd_reset_channel(ahd, 'A',
1050 /*Initiate Reset*/TRUE);
1051 break;
1052 }
1053 ahd_compile_devinfo(&devinfo, SCB_GET_OUR_ID(scb),
1054 SCB_GET_TARGET(ahd, scb),
1055 SCB_GET_LUN(scb),
1056 SCB_GET_CHANNEL(ahd, scb),
1057 ROLE_INITIATOR);
1058 targ_info = ahd_fetch_transinfo(ahd,
1059 devinfo.channel,
1060 devinfo.our_scsiid,
1061 devinfo.target,
1062 &tstate);
1063 tinfo = &targ_info->curr;
1064 ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
1065 AHD_TRANS_ACTIVE, /*paused*/TRUE);
1066 ahd_set_syncrate(ahd, &devinfo, /*period*/0,
1067 /*offset*/0, /*ppr_options*/0,
1068 AHD_TRANS_ACTIVE, /*paused*/TRUE);
1069 ahd_outb(ahd, SCB_CDB_STORE, 0);
1070 ahd_outb(ahd, SCB_CDB_STORE+1, 0);
1071 ahd_outb(ahd, SCB_CDB_STORE+2, 0);
1072 ahd_outb(ahd, SCB_CDB_STORE+3, 0);
1073 ahd_outb(ahd, SCB_CDB_STORE+4, 0);
1074 ahd_outb(ahd, SCB_CDB_STORE+5, 0);
1075 ahd_outb(ahd, SCB_CDB_LEN, 6);
1076 scb->hscb->control &= ~(TAG_ENB|SCB_TAG_TYPE);
1077 scb->hscb->control |= MK_MESSAGE;
1078 ahd_outb(ahd, SCB_CONTROL, scb->hscb->control);
1079 ahd_outb(ahd, MSG_OUT, HOST_MSG);
1080 ahd_outb(ahd, SAVED_SCSIID, scb->hscb->scsiid);
1081 /*
1082 * The lun is 0, regardless of the SCB's lun
1083 * as we have not sent an identify message.
1084 */
1085 ahd_outb(ahd, SAVED_LUN, 0);
1086 ahd_outb(ahd, SEQ_FLAGS, 0);
1087 ahd_assert_atn(ahd);
1088 scb->flags &= ~(SCB_PACKETIZED);
1089 scb->flags |= SCB_ABORT|SCB_CMDPHASE_ABORT;
1090 ahd_freeze_devq(ahd, scb);
1091 ahd_set_transaction_status(scb, CAM_REQUEUE_REQ);
1092 ahd_freeze_scb(scb);
1093
1094 /*
1095 * Allow the sequencer to continue with
1096 * non-pack processing.
1097 */
1098 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1099 ahd_outb(ahd, CLRLQOINT1, CLRLQOPHACHGINPKT);
1100 if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0) {
1101 ahd_outb(ahd, CLRLQOINT1, 0);
1102 }
1103 #ifdef AHD_DEBUG
1104 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0) {
1105 ahd_print_path(ahd, scb);
1106 printf("Unexpected command phase from "
1107 "packetized target\n");
1108 }
1109 #endif
1110 break;
1111 }
1112 }
1113 break;
1114 }
1115 case CFG4OVERRUN:
1116 {
1117 struct scb *scb;
1118 u_int scb_index;
1119
1120 #ifdef AHD_DEBUG
1121 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0) {
1122 printf("%s: CFG4OVERRUN mode = %x\n", ahd_name(ahd),
1123 ahd_inb(ahd, MODE_PTR));
1124 }
1125 #endif
1126 scb_index = ahd_get_scbptr(ahd);
1127 scb = ahd_lookup_scb(ahd, scb_index);
1128 if (scb == NULL) {
1129 /*
1130 * Attempt to transfer to an SCB that is
1131 * not outstanding.
1132 */
1133 ahd_assert_atn(ahd);
1134 ahd_outb(ahd, MSG_OUT, HOST_MSG);
1135 ahd->msgout_buf[0] = MSG_ABORT_TASK;
1136 ahd->msgout_len = 1;
1137 ahd->msgout_index = 0;
1138 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
1139 /*
1140 * Clear status received flag to prevent any
1141 * attempt to complete this bogus SCB.
1142 */
1143 ahd_outb(ahd, SCB_CONTROL,
1144 ahd_inb_scbram(ahd, SCB_CONTROL)
1145 & ~STATUS_RCVD);
1146 }
1147 break;
1148 }
1149 case DUMP_CARD_STATE:
1150 {
1151 ahd_dump_card_state(ahd);
1152 break;
1153 }
1154 case PDATA_REINIT:
1155 {
1156 #ifdef AHD_DEBUG
1157 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0) {
1158 printf("%s: PDATA_REINIT - DFCNTRL = 0x%x "
1159 "SG_CACHE_SHADOW = 0x%x\n",
1160 ahd_name(ahd), ahd_inb(ahd, DFCNTRL),
1161 ahd_inb(ahd, SG_CACHE_SHADOW));
1162 }
1163 #endif
1164 ahd_reinitialize_dataptrs(ahd);
1165 break;
1166 }
1167 case HOST_MSG_LOOP:
1168 {
1169 struct ahd_devinfo devinfo;
1170
1171 /*
1172 * The sequencer has encountered a message phase
1173 * that requires host assistance for completion.
1174 * While handling the message phase(s), we will be
1175 * notified by the sequencer after each byte is
1176 * transferred so we can track bus phase changes.
1177 *
1178 * If this is the first time we've seen a HOST_MSG_LOOP
1179 * interrupt, initialize the state of the host message
1180 * loop.
1181 */
1182 ahd_fetch_devinfo(ahd, &devinfo);
1183 if (ahd->msg_type == MSG_TYPE_NONE) {
1184 struct scb *scb;
1185 u_int scb_index;
1186 u_int bus_phase;
1187
1188 bus_phase = ahd_inb(ahd, SCSISIGI) & PHASE_MASK;
1189 if (bus_phase != P_MESGIN
1190 && bus_phase != P_MESGOUT) {
1191 printf("ahd_intr: HOST_MSG_LOOP bad "
1192 "phase 0x%x\n", bus_phase);
1193 /*
1194 * Probably transitioned to bus free before
1195 * we got here. Just punt the message.
1196 */
1197 ahd_dump_card_state(ahd);
1198 ahd_clear_intstat(ahd);
1199 ahd_restart(ahd);
1200 return;
1201 }
1202
1203 scb_index = ahd_get_scbptr(ahd);
1204 scb = ahd_lookup_scb(ahd, scb_index);
1205 if (devinfo.role == ROLE_INITIATOR) {
1206 if (bus_phase == P_MESGOUT)
1207 ahd_setup_initiator_msgout(ahd,
1208 &devinfo,
1209 scb);
1210 else {
1211 ahd->msg_type =
1212 MSG_TYPE_INITIATOR_MSGIN;
1213 ahd->msgin_index = 0;
1214 }
1215 }
1216 #if AHD_TARGET_MODE
1217 else {
1218 if (bus_phase == P_MESGOUT) {
1219 ahd->msg_type =
1220 MSG_TYPE_TARGET_MSGOUT;
1221 ahd->msgin_index = 0;
1222 }
1223 else
1224 ahd_setup_target_msgin(ahd,
1225 &devinfo,
1226 scb);
1227 }
1228 #endif
1229 }
1230
1231 ahd_handle_message_phase(ahd);
1232 break;
1233 }
1234 case NO_MATCH:
1235 {
1236 /* Ensure we don't leave the selection hardware on */
1237 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
1238 ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
1239
1240 printf("%s:%c:%d: no active SCB for reconnecting "
1241 "target - issuing BUS DEVICE RESET\n",
1242 ahd_name(ahd), 'A', ahd_inb(ahd, SELID) >> 4);
1243 printf("SAVED_SCSIID == 0x%x, SAVED_LUN == 0x%x, "
1244 "REG0 == 0x%x ACCUM = 0x%x\n",
1245 ahd_inb(ahd, SAVED_SCSIID), ahd_inb(ahd, SAVED_LUN),
1246 ahd_inw(ahd, REG0), ahd_inb(ahd, ACCUM));
1247 printf("SEQ_FLAGS == 0x%x, SCBPTR == 0x%x, BTT == 0x%x, "
1248 "SINDEX == 0x%x\n",
1249 ahd_inb(ahd, SEQ_FLAGS), ahd_get_scbptr(ahd),
1250 ahd_find_busy_tcl(ahd,
1251 BUILD_TCL(ahd_inb(ahd, SAVED_SCSIID),
1252 ahd_inb(ahd, SAVED_LUN))),
1253 ahd_inw(ahd, SINDEX));
1254 printf("SELID == 0x%x, SCB_SCSIID == 0x%x, SCB_LUN == 0x%x, "
1255 "SCB_CONTROL == 0x%x\n",
1256 ahd_inb(ahd, SELID), ahd_inb_scbram(ahd, SCB_SCSIID),
1257 ahd_inb_scbram(ahd, SCB_LUN),
1258 ahd_inb_scbram(ahd, SCB_CONTROL));
1259 printf("SCSIBUS[0] == 0x%x, SCSISIGI == 0x%x\n",
1260 ahd_inb(ahd, SCSIBUS), ahd_inb(ahd, SCSISIGI));
1261 printf("SXFRCTL0 == 0x%x\n", ahd_inb(ahd, SXFRCTL0));
1262 printf("SEQCTL0 == 0x%x\n", ahd_inb(ahd, SEQCTL0));
1263 ahd_dump_card_state(ahd);
1264 ahd->msgout_buf[0] = MSG_BUS_DEV_RESET;
1265 ahd->msgout_len = 1;
1266 ahd->msgout_index = 0;
1267 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
1268 ahd_outb(ahd, MSG_OUT, HOST_MSG);
1269 ahd_assert_atn(ahd);
1270 break;
1271 }
1272 case PROTO_VIOLATION:
1273 {
1274 ahd_handle_proto_violation(ahd);
1275 break;
1276 }
1277 case IGN_WIDE_RES:
1278 {
1279 struct ahd_devinfo devinfo;
1280
1281 ahd_fetch_devinfo(ahd, &devinfo);
1282 ahd_handle_ign_wide_residue(ahd, &devinfo);
1283 break;
1284 }
1285 case BAD_PHASE:
1286 {
1287 u_int lastphase;
1288
1289 lastphase = ahd_inb(ahd, LASTPHASE);
1290 printf("%s:%c:%d: unknown scsi bus phase %x, "
1291 "lastphase = 0x%x. Attempting to continue\n",
1292 ahd_name(ahd), 'A',
1293 SCSIID_TARGET(ahd, ahd_inb(ahd, SAVED_SCSIID)),
1294 lastphase, ahd_inb(ahd, SCSISIGI));
1295 break;
1296 }
1297 case MISSED_BUSFREE:
1298 {
1299 u_int lastphase;
1300
1301 lastphase = ahd_inb(ahd, LASTPHASE);
1302 printf("%s:%c:%d: Missed busfree. "
1303 "Lastphase = 0x%x, Curphase = 0x%x\n",
1304 ahd_name(ahd), 'A',
1305 SCSIID_TARGET(ahd, ahd_inb(ahd, SAVED_SCSIID)),
1306 lastphase, ahd_inb(ahd, SCSISIGI));
1307 ahd_restart(ahd);
1308 return;
1309 }
1310 case DATA_OVERRUN:
1311 {
1312 /*
1313 * When the sequencer detects an overrun, it
1314 * places the controller in "BITBUCKET" mode
1315 * and allows the target to complete its transfer.
1316 * Unfortunately, none of the counters get updated
1317 * when the controller is in this mode, so we have
1318 * no way of knowing how large the overrun was.
1319 */
1320 struct scb *scb;
1321 u_int scbindex;
1322 #ifdef AHD_DEBUG
1323 u_int lastphase;
1324 #endif
1325
1326 scbindex = ahd_get_scbptr(ahd);
1327 scb = ahd_lookup_scb(ahd, scbindex);
1328 #ifdef AHD_DEBUG
1329 lastphase = ahd_inb(ahd, LASTPHASE);
1330 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0) {
1331 ahd_print_path(ahd, scb);
1332 printf("data overrun detected %s. Tag == 0x%x.\n",
1333 ahd_lookup_phase_entry(lastphase)->phasemsg,
1334 SCB_GET_TAG(scb));
1335 ahd_print_path(ahd, scb);
1336 printf("%s seen Data Phase. Length = %ld. "
1337 "NumSGs = %d.\n",
1338 ahd_inb(ahd, SEQ_FLAGS) & DPHASE
1339 ? "Have" : "Haven't",
1340 ahd_get_transfer_length(scb), scb->sg_count);
1341 ahd_dump_sglist(scb);
1342 }
1343 #endif
1344
1345 /*
1346 * Set this and it will take effect when the
1347 * target does a command complete.
1348 */
1349 ahd_freeze_devq(ahd, scb);
1350 ahd_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1351 ahd_freeze_scb(scb);
1352 break;
1353 }
1354 case MKMSG_FAILED:
1355 {
1356 struct ahd_devinfo devinfo;
1357 struct scb *scb;
1358 u_int scbid;
1359
1360 ahd_fetch_devinfo(ahd, &devinfo);
1361 printf("%s:%c:%d:%d: Attempt to issue message failed\n",
1362 ahd_name(ahd), devinfo.channel, devinfo.target,
1363 devinfo.lun);
1364 scbid = ahd_get_scbptr(ahd);
1365 scb = ahd_lookup_scb(ahd, scbid);
1366 if (scb != NULL
1367 && (scb->flags & SCB_RECOVERY_SCB) != 0)
1368 /*
1369 * Ensure that we didn't put a second instance of this
1370 * SCB into the QINFIFO.
1371 */
1372 ahd_search_qinfifo(ahd, SCB_GET_TARGET(ahd, scb),
1373 SCB_GET_CHANNEL(ahd, scb),
1374 SCB_GET_LUN(scb), SCB_GET_TAG(scb),
1375 ROLE_INITIATOR, /*status*/0,
1376 SEARCH_REMOVE);
1377 ahd_outb(ahd, SCB_CONTROL,
1378 ahd_inb_scbram(ahd, SCB_CONTROL) & ~MK_MESSAGE);
1379 break;
1380 }
1381 case TASKMGMT_FUNC_COMPLETE:
1382 {
1383 u_int scbid;
1384 struct scb *scb;
1385
1386 scbid = ahd_get_scbptr(ahd);
1387 scb = ahd_lookup_scb(ahd, scbid);
1388 if (scb != NULL) {
1389 u_int lun;
1390 u_int tag;
1391 cam_status error;
1392
1393 ahd_print_path(ahd, scb);
1394 printf("Task Management Func 0x%x Complete\n",
1395 scb->hscb->task_management);
1396 lun = CAM_LUN_WILDCARD;
1397 tag = SCB_LIST_NULL;
1398
1399 switch (scb->hscb->task_management) {
1400 case SIU_TASKMGMT_ABORT_TASK:
1401 tag = SCB_GET_TAG(scb);
1402 case SIU_TASKMGMT_ABORT_TASK_SET:
1403 case SIU_TASKMGMT_CLEAR_TASK_SET:
1404 lun = scb->hscb->lun;
1405 error = CAM_REQ_ABORTED;
1406 ahd_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
1407 'A', lun, tag, ROLE_INITIATOR,
1408 error);
1409 break;
1410 case SIU_TASKMGMT_LUN_RESET:
1411 lun = scb->hscb->lun;
1412 case SIU_TASKMGMT_TARGET_RESET:
1413 {
1414 struct ahd_devinfo devinfo;
1415
1416 ahd_scb_devinfo(ahd, &devinfo, scb);
1417 error = CAM_BDR_SENT;
1418 ahd_handle_devreset(ahd, &devinfo, lun,
1419 CAM_BDR_SENT,
1420 lun != CAM_LUN_WILDCARD
1421 ? "Lun Reset"
1422 : "Target Reset",
1423 /*verbose_level*/0);
1424 break;
1425 }
1426 default:
1427 panic("Unexpected TaskMgmt Func\n");
1428 break;
1429 }
1430 }
1431 break;
1432 }
1433 case TASKMGMT_CMD_CMPLT_OKAY:
1434 {
1435 u_int scbid;
1436 struct scb *scb;
1437
1438 /*
1439 * An ABORT TASK TMF failed to be delivered before
1440 * the targeted command completed normally.
1441 */
1442 scbid = ahd_get_scbptr(ahd);
1443 scb = ahd_lookup_scb(ahd, scbid);
1444 if (scb != NULL) {
1445 /*
1446 * Remove the second instance of this SCB from
1447 * the QINFIFO if it is still there.
1448 */
1449 ahd_print_path(ahd, scb);
1450 printf("SCB completes before TMF\n");
1451 /*
1452 * Handle losing the race. Wait until any
1453 * current selection completes. We will then
1454 * set the TMF back to zero in this SCB so that
1455 * the sequencer doesn't bother to issue another
1456 * sequencer interrupt for its completion.
1457 */
1458 while ((ahd_inb(ahd, SCSISEQ0) & ENSELO) != 0
1459 && (ahd_inb(ahd, SSTAT0) & SELDO) == 0
1460 && (ahd_inb(ahd, SSTAT1) & SELTO) == 0)
1461 ;
1462 ahd_outb(ahd, SCB_TASK_MANAGEMENT, 0);
1463 ahd_search_qinfifo(ahd, SCB_GET_TARGET(ahd, scb),
1464 SCB_GET_CHANNEL(ahd, scb),
1465 SCB_GET_LUN(scb), SCB_GET_TAG(scb),
1466 ROLE_INITIATOR, /*status*/0,
1467 SEARCH_REMOVE);
1468 }
1469 break;
1470 }
1471 case TRACEPOINT0:
1472 case TRACEPOINT1:
1473 case TRACEPOINT2:
1474 case TRACEPOINT3:
1475 printf("%s: Tracepoint %d\n", ahd_name(ahd),
1476 seqintcode - TRACEPOINT0);
1477 break;
1478 case NO_SEQINT:
1479 break;
1480 case SAW_HWERR:
1481 ahd_handle_hwerrint(ahd);
1482 break;
1483 default:
1484 printf("%s: Unexpected SEQINTCODE %d\n", ahd_name(ahd),
1485 seqintcode);
1486 break;
1487 }
1488 /*
1489 * The sequencer is paused immediately on
1490 * a SEQINT, so we should restart it when
1491 * we're done.
1492 */
1493 ahd_unpause(ahd);
1494 }
1495
1496 void
1497 ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
1498 {
1499 struct scb *scb;
1500 u_int status0;
1501 u_int status3;
1502 u_int status;
1503 u_int lqistat1;
1504 u_int lqostat0;
1505 u_int scbid;
1506 u_int busfreetime;
1507
1508 ahd_update_modes(ahd);
1509 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1510
1511 status3 = ahd_inb(ahd, SSTAT3) & (NTRAMPERR|OSRAMPERR);
1512 status0 = ahd_inb(ahd, SSTAT0) & (IOERR|OVERRUN|SELDI|SELDO);
1513 status = ahd_inb(ahd, SSTAT1) & (SELTO|SCSIRSTI|BUSFREE|SCSIPERR);
1514 lqistat1 = ahd_inb(ahd, LQISTAT1);
1515 lqostat0 = ahd_inb(ahd, LQOSTAT0);
1516 busfreetime = ahd_inb(ahd, SSTAT2) & BUSFREETIME;
1517 if ((status0 & (SELDI|SELDO)) != 0) {
1518 u_int simode0;
1519
1520 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
1521 simode0 = ahd_inb(ahd, SIMODE0);
1522 status0 &= simode0 & (IOERR|OVERRUN|SELDI|SELDO);
1523 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1524 }
1525 scbid = ahd_get_scbptr(ahd);
1526 scb = ahd_lookup_scb(ahd, scbid);
1527 if (scb != NULL
1528 && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) != 0)
1529 scb = NULL;
1530
1531 /* Make sure the sequencer is in a safe location. */
1532 ahd_clear_critical_section(ahd);
1533
1534 if ((status0 & IOERR) != 0) {
1535 u_int now_lvd;
1536
1537 now_lvd = ahd_inb(ahd, SBLKCTL) & ENAB40;
1538 printf("%s: Transceiver State Has Changed to %s mode\n",
1539 ahd_name(ahd), now_lvd ? "LVD" : "SE");
1540 ahd_outb(ahd, CLRSINT0, CLRIOERR);
1541 /*
1542 * A change in I/O mode is equivalent to a bus reset.
1543 */
1544 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1545 ahd_pause(ahd);
1546 ahd_setup_iocell_workaround(ahd);
1547 ahd_unpause(ahd);
1548 } else if ((status0 & OVERRUN) != 0) {
1549 printf("%s: SCSI offset overrun detected. Resetting bus.\n",
1550 ahd_name(ahd));
1551 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1552 } else if ((status & SCSIRSTI) != 0) {
1553 printf("%s: Someone reset channel A\n", ahd_name(ahd));
1554 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/FALSE);
1555 } else if ((status & SCSIPERR) != 0) {
1556 ahd_handle_transmission_error(ahd);
1557 } else if (lqostat0 != 0) {
1558 printf("%s: lqostat0 == 0x%x!\n", ahd_name(ahd), lqostat0);
1559 ahd_outb(ahd, CLRLQOINT0, lqostat0);
1560 if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0) {
1561 ahd_outb(ahd, CLRLQOINT1, 0);
1562 }
1563 } else if ((status & SELTO) != 0) {
1564 u_int scbid1;
1565
1566 /* Stop the selection */
1567 ahd_outb(ahd, SCSISEQ0, 0);
1568
1569 /* No more pending messages */
1570 ahd_clear_msg_state(ahd);
1571
1572 /* Clear interrupt state */
1573 ahd_outb(ahd, CLRSINT1, CLRSELTIMEO|CLRBUSFREE|CLRSCSIPERR);
1574
1575 /*
1576 * Although the driver does not care about the
1577 * 'Selection in Progress' status bit, the busy
1578 * LED does. SELINGO is only cleared by a sucessfull
1579 * selection, so we must manually clear it to insure
1580 * the LED turns off just incase no future successful
1581 * selections occur (e.g. no devices on the bus).
1582 */
1583 ahd_outb(ahd, CLRSINT0, CLRSELINGO);
1584
1585 scbid1 = ahd_inw(ahd, WAITING_TID_HEAD);
1586 scb = ahd_lookup_scb(ahd, scbid1);
1587 if (scb == NULL) {
1588 printf("%s: ahd_intr - referenced scb not "
1589 "valid during SELTO scb(0x%x)\n",
1590 ahd_name(ahd), scbid1);
1591 ahd_dump_card_state(ahd);
1592 } else {
1593 struct ahd_devinfo devinfo;
1594 #ifdef AHD_DEBUG
1595 if ((ahd_debug & AHD_SHOW_SELTO) != 0) {
1596 ahd_print_path(ahd, scb);
1597 printf("Saw Selection Timeout for SCB 0x%x\n",
1598 scbid1);
1599 }
1600 #endif
1601 /*
1602 * Force a renegotiation with this target just in
1603 * case the cable was pulled and will later be
1604 * re-attached. The target may forget its negotiation
1605 * settings with us should it attempt to reselect
1606 * during the interruption. The target will not issue
1607 * a unit attention in this case, so we must always
1608 * renegotiate.
1609 */
1610 ahd_scb_devinfo(ahd, &devinfo, scb);
1611 ahd_force_renegotiation(ahd, &devinfo);
1612 ahd_set_transaction_status(scb, CAM_SEL_TIMEOUT);
1613 ahd_freeze_devq(ahd, scb);
1614 }
1615 ahd_outb(ahd, CLRINT, CLRSCSIINT);
1616 ahd_iocell_first_selection(ahd);
1617 ahd_unpause(ahd);
1618 } else if ((status0 & (SELDI|SELDO)) != 0) {
1619 ahd_iocell_first_selection(ahd);
1620 ahd_unpause(ahd);
1621 } else if (status3 != 0) {
1622 printf("%s: SCSI Cell parity error SSTAT3 == 0x%x\n",
1623 ahd_name(ahd), status3);
1624 ahd_outb(ahd, CLRSINT3, status3);
1625 } else if ((lqistat1 & (LQIPHASE_LQ|LQIPHASE_NLQ)) != 0) {
1626 ahd_handle_lqiphase_error(ahd, lqistat1);
1627 } else if ((lqistat1 & LQICRCI_NLQ) != 0) {
1628 /*
1629 * This status can be delayed during some
1630 * streaming operations. The SCSIPHASE
1631 * handler has already dealt with this case
1632 * so just clear the error.
1633 */
1634 ahd_outb(ahd, CLRLQIINT1, CLRLQICRCI_NLQ);
1635 } else if ((status & BUSFREE) != 0) {
1636 u_int lqostat1;
1637 int restart;
1638 int clear_fifo;
1639 int packetized;
1640 u_int mode;
1641
1642 /*
1643 * Clear our selection hardware as soon as possible.
1644 * We may have an entry in the waiting Q for this target,
1645 * that is affected by this busfree and we don't want to
1646 * go about selecting the target while we handle the event.
1647 */
1648 ahd_outb(ahd, SCSISEQ0, 0);
1649
1650 /*
1651 * Determine what we were up to at the time of
1652 * the busfree.
1653 */
1654 mode = AHD_MODE_SCSI;
1655 busfreetime = ahd_inb(ahd, SSTAT2) & BUSFREETIME;
1656 lqostat1 = ahd_inb(ahd, LQOSTAT1);
1657 switch (busfreetime) {
1658 case BUSFREE_DFF0:
1659 case BUSFREE_DFF1:
1660 {
1661 u_int scbid1;
1662 struct scb *scb1;
1663
1664 mode = busfreetime == BUSFREE_DFF0
1665 ? AHD_MODE_DFF0 : AHD_MODE_DFF1;
1666 ahd_set_modes(ahd, mode, mode);
1667 scbid1 = ahd_get_scbptr(ahd);
1668 scb1 = ahd_lookup_scb(ahd, scbid1);
1669 if (scb1 == NULL) {
1670 printf("%s: Invalid SCB %d in DFF%d "
1671 "during unexpected busfree\n",
1672 ahd_name(ahd), scbid1, mode);
1673 packetized = 0;
1674 } else
1675 packetized =
1676 (scb1->flags & SCB_PACKETIZED) != 0;
1677 clear_fifo = 1;
1678 break;
1679 }
1680 case BUSFREE_LQO:
1681 clear_fifo = 0;
1682 packetized = 1;
1683 break;
1684 default:
1685 clear_fifo = 0;
1686 packetized = (lqostat1 & LQOBUSFREE) != 0;
1687 if (!packetized
1688 && ahd_inb(ahd, LASTPHASE) == P_BUSFREE)
1689 packetized = 1;
1690 break;
1691 }
1692
1693 #ifdef AHD_DEBUG
1694 if ((ahd_debug & AHD_SHOW_MISC) != 0)
1695 printf("Saw Busfree. Busfreetime = 0x%x.\n",
1696 busfreetime);
1697 #endif
1698 /*
1699 * Busfrees that occur in non-packetized phases are
1700 * handled by the nonpkt_busfree handler.
1701 */
1702 if (packetized && ahd_inb(ahd, LASTPHASE) == P_BUSFREE) {
1703 restart = ahd_handle_pkt_busfree(ahd, busfreetime);
1704 } else {
1705 packetized = 0;
1706 restart = ahd_handle_nonpkt_busfree(ahd);
1707 }
1708 /*
1709 * Clear the busfree interrupt status. The setting of
1710 * the interrupt is a pulse, so in a perfect world, we
1711 * would not need to muck with the ENBUSFREE logic. This
1712 * would ensure that if the bus moves on to another
1713 * connection, busfree protection is still in force. If
1714 * BUSFREEREV is broken, however, we must manually clear
1715 * the ENBUSFREE if the busfree occurred during a non-pack
1716 * connection so that we don't get false positives during
1717 * future, packetized, connections.
1718 */
1719 ahd_outb(ahd, CLRSINT1, CLRBUSFREE);
1720 if (packetized == 0
1721 && (ahd->bugs & AHD_BUSFREEREV_BUG) != 0)
1722 ahd_outb(ahd, SIMODE1,
1723 ahd_inb(ahd, SIMODE1) & ~ENBUSFREE);
1724
1725 if (clear_fifo)
1726 ahd_clear_fifo(ahd, mode);
1727
1728 ahd_clear_msg_state(ahd);
1729 ahd_outb(ahd, CLRINT, CLRSCSIINT);
1730 if (restart) {
1731 ahd_restart(ahd);
1732 } else {
1733 ahd_unpause(ahd);
1734 }
1735 } else {
1736 printf("%s: Missing case in ahd_handle_scsiint. status = %x\n",
1737 ahd_name(ahd), status);
1738 ahd_dump_card_state(ahd);
1739 ahd_clear_intstat(ahd);
1740 ahd_unpause(ahd);
1741 }
1742 }
1743
1744 static void
1745 ahd_handle_transmission_error(struct ahd_softc *ahd)
1746 {
1747 struct scb *scb;
1748 u_int scbid;
1749 u_int lqistat1;
1750 u_int lqistat2;
1751 u_int msg_out;
1752 u_int curphase;
1753 u_int lastphase;
1754 u_int perrdiag;
1755 u_int cur_col;
1756 int silent;
1757
1758 scb = NULL;
1759 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1760 lqistat1 = ahd_inb(ahd, LQISTAT1) & ~(LQIPHASE_LQ|LQIPHASE_NLQ);
1761 lqistat2 = ahd_inb(ahd, LQISTAT2);
1762 if ((lqistat1 & (LQICRCI_NLQ|LQICRCI_LQ)) == 0
1763 && (ahd->bugs & AHD_NLQICRC_DELAYED_BUG) != 0) {
1764 u_int lqistate;
1765
1766 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
1767 lqistate = ahd_inb(ahd, LQISTATE);
1768 if ((lqistate >= 0x1E && lqistate <= 0x24)
1769 || (lqistate == 0x29)) {
1770 #ifdef AHD_DEBUG
1771 if ((ahd_debug & AHD_SHOW_RECOVERY) != 0) {
1772 printf("%s: NLQCRC found via LQISTATE\n",
1773 ahd_name(ahd));
1774 }
1775 #endif
1776 lqistat1 |= LQICRCI_NLQ;
1777 }
1778 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1779 }
1780
1781 ahd_outb(ahd, CLRLQIINT1, lqistat1);
1782 lastphase = ahd_inb(ahd, LASTPHASE);
1783 curphase = ahd_inb(ahd, SCSISIGI) & PHASE_MASK;
1784 perrdiag = ahd_inb(ahd, PERRDIAG);
1785 msg_out = MSG_INITIATOR_DET_ERR;
1786 ahd_outb(ahd, CLRSINT1, CLRSCSIPERR);
1787
1788 /*
1789 * Try to find the SCB associated with this error.
1790 */
1791 silent = FALSE;
1792 if (lqistat1 == 0
1793 || (lqistat1 & LQICRCI_NLQ) != 0) {
1794 if ((lqistat1 & (LQICRCI_NLQ|LQIOVERI_NLQ)) != 0)
1795 ahd_set_active_fifo(ahd);
1796 scbid = ahd_get_scbptr(ahd);
1797 scb = ahd_lookup_scb(ahd, scbid);
1798 if (scb != NULL && SCB_IS_SILENT(scb))
1799 silent = TRUE;
1800 }
1801
1802 cur_col = 0;
1803 if (silent == FALSE) {
1804 printf("%s: Transmission error detected\n", ahd_name(ahd));
1805 ahd_lqistat1_print(lqistat1, &cur_col, 50);
1806 ahd_lastphase_print(lastphase, &cur_col, 50);
1807 ahd_scsisigi_print(curphase, &cur_col, 50);
1808 ahd_perrdiag_print(perrdiag, &cur_col, 50);
1809 printf("\n");
1810 ahd_dump_card_state(ahd);
1811 }
1812
1813 if ((lqistat1 & (LQIOVERI_LQ|LQIOVERI_NLQ)) != 0) {
1814 if (silent == FALSE) {
1815 printf("%s: Gross protocol error during incoming "
1816 "packet. lqistat1 == 0x%x. Resetting bus.\n",
1817 ahd_name(ahd), lqistat1);
1818 }
1819 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1820 return;
1821 } else if ((lqistat1 & LQICRCI_LQ) != 0) {
1822 /*
1823 * A CRC error has been detected on an incoming LQ.
1824 * The bus is currently hung on the last ACK.
1825 * Hit LQIRETRY to release the last ack, and
1826 * wait for the sequencer to determine that ATNO
1827 * is asserted while in message out to take us
1828 * to our host message loop. No NONPACKREQ or
1829 * LQIPHASE type errors will occur in this
1830 * scenario. After this first LQIRETRY, the LQI
1831 * manager will be in ISELO where it will
1832 * happily sit until another packet phase begins.
1833 * Unexpected bus free detection is enabled
1834 * through any phases that occur after we release
1835 * this last ack until the LQI manager sees a
1836 * packet phase. This implies we may have to
1837 * ignore a perfectly valid "unexected busfree"
1838 * after our "initiator detected error" message is
1839 * sent. A busfree is the expected response after
1840 * we tell the target that it's L_Q was corrupted.
1841 * (SPI4R09 10.7.3.3.3)
1842 */
1843 ahd_outb(ahd, LQCTL2, LQIRETRY);
1844 printf("LQIRetry for LQICRCI_LQ to release ACK\n");
1845 } else if ((lqistat1 & LQICRCI_NLQ) != 0) {
1846 /*
1847 * We detected a CRC error in a NON-LQ packet.
1848 * The hardware has varying behavior in this situation
1849 * depending on whether this packet was part of a
1850 * stream or not.
1851 *
1852 * PKT by PKT mode:
1853 * The hardware has already acked the complete packet.
1854 * If the target honors our outstanding ATN condition,
1855 * we should be (or soon will be) in MSGOUT phase.
1856 * This will trigger the LQIPHASE_LQ status bit as the
1857 * hardware was expecting another LQ. Unexpected
1858 * busfree detection is enabled. Once LQIPHASE_LQ is
1859 * true (first entry into host message loop is much
1860 * the same), we must clear LQIPHASE_LQ and hit
1861 * LQIRETRY so the hardware is ready to handle
1862 * a future LQ. NONPACKREQ will not be asserted again
1863 * once we hit LQIRETRY until another packet is
1864 * processed. The target may either go busfree
1865 * or start another packet in response to our message.
1866 *
1867 * Read Streaming P0 asserted:
1868 * If we raise ATN and the target completes the entire
1869 * stream (P0 asserted during the last packet), the
1870 * hardware will ack all data and return to the ISTART
1871 * state. When the target reponds to our ATN condition,
1872 * LQIPHASE_LQ will be asserted. We should respond to
1873 * this with an LQIRETRY to prepare for any future
1874 * packets. NONPACKREQ will not be asserted again
1875 * once we hit LQIRETRY until another packet is
1876 * processed. The target may either go busfree or
1877 * start another packet in response to our message.
1878 * Busfree detection is enabled.
1879 *
1880 * Read Streaming P0 not asserted:
1881 * If we raise ATN and the target transitions to
1882 * MSGOUT in or after a packet where P0 is not
1883 * asserted, the hardware will assert LQIPHASE_NLQ.
1884 * We should respond to the LQIPHASE_NLQ with an
1885 * LQIRETRY. Should the target stay in a non-pkt
1886 * phase after we send our message, the hardware
1887 * will assert LQIPHASE_LQ. Recovery is then just as
1888 * listed above for the read streaming with P0 asserted.
1889 * Busfree detection is enabled.
1890 */
1891 if (silent == FALSE)
1892 printf("LQICRC_NLQ\n");
1893 if (scb == NULL) {
1894 printf("%s: No SCB valid for LQICRC_NLQ. "
1895 "Resetting bus\n", ahd_name(ahd));
1896 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1897 return;
1898 }
1899 } else if ((lqistat1 & LQIBADLQI) != 0) {
1900 printf("Need to handle BADLQI!\n");
1901 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1902 return;
1903 } else if ((perrdiag & (PARITYERR|PREVPHASE)) == PARITYERR) {
1904 if ((curphase & ~P_DATAIN_DT) != 0) {
1905 /* Ack the byte. So we can continue. */
1906 if (silent == FALSE)
1907 printf("Acking %s to clear perror\n",
1908 ahd_lookup_phase_entry(curphase)->phasemsg);
1909 ahd_inb(ahd, SCSIDAT);
1910 }
1911
1912 if (curphase == P_MESGIN)
1913 msg_out = MSG_PARITY_ERROR;
1914 }
1915
1916 /*
1917 * We've set the hardware to assert ATN if we
1918 * get a parity error on "in" phases, so all we
1919 * need to do is stuff the message buffer with
1920 * the appropriate message. "In" phases have set
1921 * mesg_out to something other than MSG_NOP.
1922 */
1923 ahd->send_msg_perror = msg_out;
1924 if (scb != NULL && msg_out == MSG_INITIATOR_DET_ERR)
1925 scb->flags |= SCB_TRANSMISSION_ERROR;
1926 ahd_outb(ahd, MSG_OUT, HOST_MSG);
1927 ahd_outb(ahd, CLRINT, CLRSCSIINT);
1928 ahd_unpause(ahd);
1929 }
1930
1931 static void
1932 ahd_handle_lqiphase_error(struct ahd_softc *ahd, u_int lqistat1)
1933 {
1934 /*
1935 * Clear the sources of the interrupts.
1936 */
1937 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
1938 ahd_outb(ahd, CLRLQIINT1, lqistat1);
1939
1940 /*
1941 * If the "illegal" phase changes were in response
1942 * to our ATN to flag a CRC error, AND we ended up
1943 * on packet boundaries, clear the error, restart the
1944 * LQI manager as appropriate, and go on our merry
1945 * way toward sending the message. Otherwise, reset
1946 * the bus to clear the error.
1947 */
1948 ahd_set_active_fifo(ahd);
1949 if ((ahd_inb(ahd, SCSISIGO) & ATNO) != 0
1950 && (ahd_inb(ahd, MDFFSTAT) & DLZERO) != 0) {
1951 if ((lqistat1 & LQIPHASE_LQ) != 0) {
1952 printf("LQIRETRY for LQIPHASE_LQ\n");
1953 ahd_outb(ahd, LQCTL2, LQIRETRY);
1954 } else if ((lqistat1 & LQIPHASE_NLQ) != 0) {
1955 printf("LQIRETRY for LQIPHASE_NLQ\n");
1956 ahd_outb(ahd, LQCTL2, LQIRETRY);
1957 } else
1958 panic("ahd_handle_lqiphase_error: No phase errors\n");
1959 ahd_dump_card_state(ahd);
1960 ahd_outb(ahd, CLRINT, CLRSCSIINT);
1961 ahd_unpause(ahd);
1962 } else {
1963 printf("Reseting Channel for LQI Phase error\n");
1964 ahd_dump_card_state(ahd);
1965 ahd_reset_channel(ahd, 'A', /*Initiate Reset*/TRUE);
1966 }
1967 }
1968
1969 /*
1970 * Packetized unexpected or expected busfree.
1971 * Entered in mode based on busfreetime.
1972 */
1973 static int
1974 ahd_handle_pkt_busfree(struct ahd_softc *ahd, u_int busfreetime)
1975 {
1976 u_int lqostat1;
1977
1978 AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
1979 ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
1980 lqostat1 = ahd_inb(ahd, LQOSTAT1);
1981 if ((lqostat1 & LQOBUSFREE) != 0) {
1982 struct scb *scb;
1983 u_int scbid;
1984 u_int saved_scbptr;
1985 u_int waiting_h;
1986 u_int waiting_t;
1987 u_int next;
1988
1989 if ((busfreetime & BUSFREE_LQO) == 0)
1990 printf("%s: Warning, BUSFREE time is 0x%x. "
1991 "Expected BUSFREE_LQO.\n",
1992 ahd_name(ahd), busfreetime);
1993 /*
1994 * The LQO manager detected an unexpected busfree
1995 * either:
1996 *
1997 * 1) During an outgoing LQ.
1998 * 2) After an outgoing LQ but before the first
1999 * REQ of the command packet.
2000 * 3) During an outgoing command packet.
2001 *
2002 * In all cases, CURRSCB is pointing to the
2003 * SCB that encountered the failure. Clean
2004 * up the queue, clear SELDO and LQOBUSFREE,
2005 * and allow the sequencer to restart the select
2006 * out at its lesure.
2007 */
2008 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
2009 scbid = ahd_inw(ahd, CURRSCB);
2010 scb = ahd_lookup_scb(ahd, scbid);
2011 if (scb == NULL)
2012 panic("SCB not valid during LQOBUSFREE");
2013 /*
2014 * Clear the status.
2015 */
2016 ahd_outb(ahd, CLRLQOINT1, CLRLQOBUSFREE);
2017 if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0)
2018 ahd_outb(ahd, CLRLQOINT1, 0);
2019 ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
2020 ahd_flush_device_writes(ahd);
2021 ahd_outb(ahd, CLRSINT0, CLRSELDO);
2022
2023 /*
2024 * Return the LQO manager to its idle loop. It will
2025 * not do this automatically if the busfree occurs
2026 * after the first REQ of either the LQ or command
2027 * packet or between the LQ and command packet.
2028 */
2029 ahd_outb(ahd, LQCTL2, ahd_inb(ahd, LQCTL2) | LQOTOIDLE);
2030
2031 /*
2032 * Update the waiting for selection queue so
2033 * we restart on the correct SCB.
2034 */
2035 waiting_h = ahd_inw(ahd, WAITING_TID_HEAD);
2036 saved_scbptr = ahd_get_scbptr(ahd);
2037 if (waiting_h != scbid) {
2038
2039 ahd_outw(ahd, WAITING_TID_HEAD, scbid);
2040 waiting_t = ahd_inw(ahd, WAITING_TID_TAIL);
2041 if (waiting_t == waiting_h) {
2042 ahd_outw(ahd, WAITING_TID_TAIL, scbid);
2043 next = SCB_LIST_NULL;
2044 } else {
2045 ahd_set_scbptr(ahd, waiting_h);
2046 next = ahd_inw_scbram(ahd, SCB_NEXT2);
2047 }
2048 ahd_set_scbptr(ahd, scbid);
2049 ahd_outw(ahd, SCB_NEXT2, next);
2050 }
2051 ahd_set_scbptr(ahd, saved_scbptr);
2052 if (scb->crc_retry_count < AHD_MAX_LQ_CRC_ERRORS) {
2053 if (SCB_IS_SILENT(scb) == FALSE) {
2054 ahd_print_path(ahd, scb);
2055 printf("Probable outgoing LQ CRC error. "
2056 "Retrying command\n");
2057 }
2058 scb->crc_retry_count++;
2059 } else {
2060 ahd_set_transaction_status(scb, CAM_UNCOR_PARITY);
2061 ahd_freeze_scb(scb);
2062 ahd_freeze_devq(ahd, scb);
2063 }
2064 /* Return unpausing the sequencer. */
2065 return (0);
2066 } else if ((ahd_inb(ahd, PERRDIAG) & PARITYERR) != 0) {
2067 /*
2068 * Ignore what are really parity errors that
2069 * occur on the last REQ of a free running
2070 * clock prior to going busfree. Some drives
2071 * do not properly active negate just before
2072 * going busfree resulting in a parity glitch.
2073 */
2074 ahd_outb(ahd, CLRSINT1, CLRSCSIPERR|CLRBUSFREE);
2075 #ifdef AHD_DEBUG
2076 if ((ahd_debug & AHD_SHOW_MASKED_ERRORS) != 0)
2077 printf("%s: Parity on last REQ detected "
2078 "during busfree phase.\n",
2079 ahd_name(ahd));
2080 #endif
2081 /* Return unpausing the sequencer. */
2082 return (0);
2083 }
2084 if (ahd->src_mode != AHD_MODE_SCSI) {
2085 u_int scbid;
2086 struct scb *scb;
2087
2088 scbid = ahd_get_scbptr(ahd);
2089 scb = ahd_lookup_scb(ahd, scbid);
2090 ahd_print_path(ahd, scb);
2091 printf("Unexpected PKT busfree condition\n");
2092 ahd_dump_card_state(ahd);
2093 ahd_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb), 'A',
2094 SCB_GET_LUN(scb), SCB_GET_TAG(scb),
2095 ROLE_INITIATOR, CAM_UNEXP_BUSFREE);
2096
2097 /* Return restarting the sequencer. */
2098 return (1);
2099 }
2100 printf("%s: Unexpected PKT busfree condition\n", ahd_name(ahd));
2101 ahd_dump_card_state(ahd);
2102 /* Restart the sequencer. */
2103 return (1);
2104 }
2105
2106 /*
2107 * Non-packetized unexpected or expected busfree.
2108 */
2109 static int
2110 ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
2111 {
2112 struct ahd_devinfo devinfo;
2113 struct scb *scb;
2114 u_int lastphase;
2115 u_int saved_scsiid;
2116 u_int saved_lun;
2117 u_int target;
2118 u_int initiator_role_id;
2119 u_int scbid;
2120 u_int ppr_busfree;
2121 int printerror;
2122
2123 /*
2124 * Look at what phase we were last in. If its message out,
2125 * chances are pretty good that the busfree was in response
2126 * to one of our abort requests.
2127 */
2128 lastphase = ahd_inb(ahd, LASTPHASE);
2129 saved_scsiid = ahd_inb(ahd, SAVED_SCSIID);
2130 saved_lun = ahd_inb(ahd, SAVED_LUN);
2131 target = SCSIID_TARGET(ahd, saved_scsiid);
2132 initiator_role_id = SCSIID_OUR_ID(saved_scsiid);
2133 ahd_compile_devinfo(&devinfo, initiator_role_id,
2134 target, saved_lun, 'A', ROLE_INITIATOR);
2135 printerror = 1;
2136
2137 scbid = ahd_get_scbptr(ahd);
2138 scb = ahd_lookup_scb(ahd, scbid);
2139 if (scb != NULL
2140 && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) != 0)
2141 scb = NULL;
2142
2143 ppr_busfree = (ahd->msg_flags & MSG_FLAG_EXPECT_PPR_BUSFREE) != 0;
2144 if (lastphase == P_MESGOUT) {
2145 u_int tag;
2146
2147 tag = SCB_LIST_NULL;
2148 if (ahd_sent_msg(ahd, AHDMSG_1B, MSG_ABORT_TAG, TRUE)
2149 || ahd_sent_msg(ahd, AHDMSG_1B, MSG_ABORT, TRUE)) {
2150 int found;
2151 int sent_msg;
2152
2153 if (scb == NULL) {
2154 ahd_print_devinfo(ahd, &devinfo);
2155 printf("Abort for unidentified "
2156 "connection completed.\n");
2157 /* restart the sequencer. */
2158 return (1);
2159 }
2160 sent_msg = ahd->msgout_buf[ahd->msgout_index - 1];
2161 ahd_print_path(ahd, scb);
2162 printf("SCB %d - Abort%s Completed.\n",
2163 SCB_GET_TAG(scb),
2164 sent_msg == MSG_ABORT_TAG ? "" : " Tag");
2165
2166 if (sent_msg == MSG_ABORT_TAG)
2167 tag = SCB_GET_TAG(scb);
2168
2169 if ((scb->flags & SCB_CMDPHASE_ABORT) != 0) {
2170 /*
2171 * This abort is in response to an
2172 * unexpected switch to command phase
2173 * for a packetized connection. Since
2174 * the identify message was never sent,
2175 * "saved lun" is 0. We really want to
2176 * abort only the SCB that encountered
2177 * this error, which could have a different
2178 * lun. The SCB will be retried so the OS
2179 * will see the UA after renegotiating to
2180 * packetized.
2181 */
2182 tag = SCB_GET_TAG(scb);
2183 saved_lun = scb->hscb->lun;
2184 }
2185 found = ahd_abort_scbs(ahd, target, 'A', saved_lun,
2186 tag, ROLE_INITIATOR,
2187 CAM_REQ_ABORTED);
2188 printf("found == 0x%x\n", found);
2189 printerror = 0;
2190 } else if (ahd_sent_msg(ahd, AHDMSG_1B,
2191 MSG_BUS_DEV_RESET, TRUE)) {
2192 #ifdef __FreeBSD__
2193 /*
2194 * Don't mark the user's request for this BDR
2195 * as completing with CAM_BDR_SENT. CAM3
2196 * specifies CAM_REQ_CMP.
2197 */
2198 if (scb != NULL
2199 && scb->io_ctx->ccb_h.func_code== XPT_RESET_DEV
2200 && ahd_match_scb(ahd, scb, target, 'A',
2201 CAM_LUN_WILDCARD, SCB_LIST_NULL,
2202 ROLE_INITIATOR))
2203 ahd_set_transaction_status(scb, CAM_REQ_CMP);
2204 #endif
2205 ahd_handle_devreset(ahd, &devinfo, CAM_LUN_WILDCARD,
2206 CAM_BDR_SENT, "Bus Device Reset",
2207 /*verbose_level*/0);
2208 printerror = 0;
2209 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_PPR, FALSE)
2210 && ppr_busfree == 0) {
2211 struct ahd_initiator_tinfo *tinfo;
2212 struct ahd_tmode_tstate *tstate;
2213
2214 /*
2215 * PPR Rejected. Try non-ppr negotiation
2216 * and retry command.
2217 */
2218 #ifdef AHD_DEBUG
2219 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2220 printf("PPR negotiation rejected busfree.\n");
2221 #endif
2222 tinfo = ahd_fetch_transinfo(ahd, devinfo.channel,
2223 devinfo.our_scsiid,
2224 devinfo.target, &tstate);
2225 tinfo->curr.transport_version = 2;
2226 tinfo->goal.transport_version = 2;
2227 tinfo->goal.ppr_options = 0;
2228 ahd_qinfifo_requeue_tail(ahd, scb);
2229 printerror = 0;
2230 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, FALSE)
2231 && ppr_busfree == 0) {
2232 /*
2233 * Negotiation Rejected. Go-narrow and
2234 * retry command.
2235 */
2236 #ifdef AHD_DEBUG
2237 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2238 printf("WDTR Negotiation rejected busfree.\n");
2239 #endif
2240 ahd_set_width(ahd, &devinfo,
2241 MSG_EXT_WDTR_BUS_8_BIT,
2242 AHD_TRANS_CUR|AHD_TRANS_GOAL,
2243 /*paused*/TRUE);
2244 ahd_qinfifo_requeue_tail(ahd, scb);
2245 printerror = 0;
2246 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, FALSE)
2247 && ppr_busfree == 0) {
2248 /*
2249 * Negotiation Rejected. Go-async and
2250 * retry command.
2251 */
2252 #ifdef AHD_DEBUG
2253 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2254 printf("SDTR negotiation rejected busfree.\n");
2255 #endif
2256 ahd_set_syncrate(ahd, &devinfo,
2257 /*period*/0, /*offset*/0,
2258 /*ppr_options*/0,
2259 AHD_TRANS_CUR|AHD_TRANS_GOAL,
2260 /*paused*/TRUE);
2261 ahd_qinfifo_requeue_tail(ahd, scb);
2262 printerror = 0;
2263 } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_IDE_BUSFREE) != 0
2264 && ahd_sent_msg(ahd, AHDMSG_1B,
2265 MSG_INITIATOR_DET_ERR, TRUE)) {
2266
2267 #ifdef AHD_DEBUG
2268 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2269 printf("Expected IDE Busfree\n");
2270 #endif
2271 printerror = 0;
2272 } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_QASREJ_BUSFREE)
2273 && ahd_sent_msg(ahd, AHDMSG_1B,
2274 MSG_MESSAGE_REJECT, TRUE)) {
2275
2276 #ifdef AHD_DEBUG
2277 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2278 printf("Expected QAS Reject Busfree\n");
2279 #endif
2280 printerror = 0;
2281 }
2282 }
2283
2284 /*
2285 * The busfree required flag is honored at the end of
2286 * the message phases. We check it last in case we
2287 * had to send some other message that caused a busfree.
2288 */
2289 if (printerror != 0
2290 && (lastphase == P_MESGIN || lastphase == P_MESGOUT)
2291 && ((ahd->msg_flags & MSG_FLAG_EXPECT_PPR_BUSFREE) != 0)) {
2292
2293 ahd_freeze_devq(ahd, scb);
2294 ahd_set_transaction_status(scb, CAM_REQUEUE_REQ);
2295 ahd_freeze_scb(scb);
2296 if ((ahd->msg_flags & MSG_FLAG_IU_REQ_CHANGED) != 0) {
2297 ahd_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
2298 SCB_GET_CHANNEL(ahd, scb),
2299 SCB_GET_LUN(scb), SCB_LIST_NULL,
2300 ROLE_INITIATOR, CAM_REQ_ABORTED);
2301 } else {
2302 #ifdef AHD_DEBUG
2303 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
2304 printf("PPR Negotiation Busfree.\n");
2305 #endif
2306 ahd_done(ahd, scb);
2307 }
2308 printerror = 0;
2309 }
2310 if (printerror != 0) {
2311 int aborted;
2312
2313 aborted = 0;
2314 if (scb != NULL) {
2315 u_int tag;
2316
2317 if ((scb->hscb->control & TAG_ENB) != 0)
2318 tag = SCB_GET_TAG(scb);
2319 else
2320 tag = SCB_LIST_NULL;
2321 ahd_print_path(ahd, scb);
2322 aborted = ahd_abort_scbs(ahd, target, 'A',
2323 SCB_GET_LUN(scb), tag,
2324 ROLE_INITIATOR,
2325 CAM_UNEXP_BUSFREE);
2326 } else {
2327 /*
2328 * We had not fully identified this connection,
2329 * so we cannot abort anything.
2330 */
2331 printf("%s: ", ahd_name(ahd));
2332 }
2333 if (lastphase != P_BUSFREE)
2334 ahd_force_renegotiation(ahd, &devinfo);
2335 printf("Unexpected busfree %s, %d SCBs aborted, "
2336 "PRGMCNT == 0x%x\n",
2337 ahd_lookup_phase_entry(lastphase)->phasemsg,
2338 aborted,
2339 ahd_inb(ahd, PRGMCNT)
2340 | (ahd_inb(ahd, PRGMCNT+1) << 8));
2341 ahd_dump_card_state(ahd);
2342 }
2343 /* Always restart the sequencer. */
2344 return (1);
2345 }
2346
2347 static void
2348 ahd_handle_proto_violation(struct ahd_softc *ahd)
2349 {
2350 struct ahd_devinfo devinfo;
2351 struct scb *scb;
2352 u_int scbid;
2353 u_int seq_flags;
2354 u_int curphase;
2355 u_int lastphase;
2356 int found;
2357
2358 ahd_fetch_devinfo(ahd, &devinfo);
2359 scbid = ahd_get_scbptr(ahd);
2360 scb = ahd_lookup_scb(ahd, scbid);
2361 seq_flags = ahd_inb(ahd, SEQ_FLAGS);
2362 curphase = ahd_inb(ahd, SCSISIGI) & PHASE_MASK;
2363 lastphase = ahd_inb(ahd, LASTPHASE);
2364 if ((seq_flags & NOT_IDENTIFIED) != 0) {
2365
2366 /*
2367 * The reconnecting target either did not send an
2368 * identify message, or did, but we didn't find an SCB
2369 * to match.
2370 */
2371 ahd_print_devinfo(ahd, &devinfo);
2372 printf("Target did not send an IDENTIFY message. "
2373 "LASTPHASE = 0x%x.\n", lastphase);
2374 scb = NULL;
2375 } else if (scb == NULL) {
2376 /*
2377 * We don't seem to have an SCB active for this
2378 * transaction. Print an error and reset the bus.
2379 */
2380 ahd_print_devinfo(ahd, &devinfo);
2381 printf("No SCB found during protocol violation\n");
2382 goto proto_violation_reset;
2383 } else {
2384 ahd_set_transaction_status(scb, CAM_SEQUENCE_FAIL);
2385 if ((seq_flags & NO_CDB_SENT) != 0) {
2386 ahd_print_path(ahd, scb);
2387 printf("No or incomplete CDB sent to device.\n");
2388 } else if ((ahd_inb_scbram(ahd, SCB_CONTROL)
2389 & STATUS_RCVD) == 0) {
2390 /*
2391 * The target never bothered to provide status to
2392 * us prior to completing the command. Since we don't
2393 * know the disposition of this command, we must attempt
2394 * to abort it. Assert ATN and prepare to send an abort
2395 * message.
2396 */
2397 ahd_print_path(ahd, scb);
2398 printf("Completed command without status.\n");
2399 } else {
2400 ahd_print_path(ahd, scb);
2401 printf("Unknown protocol violation.\n");
2402 ahd_dump_card_state(ahd);
2403 }
2404 }
2405 if ((lastphase & ~P_DATAIN_DT) == 0
2406 || lastphase == P_COMMAND) {
2407 proto_violation_reset:
2408 /*
2409 * Target either went directly to data
2410 * phase or didn't respond to our ATN.
2411 * The only safe thing to do is to blow
2412 * it away with a bus reset.
2413 */
2414 found = ahd_reset_channel(ahd, 'A', TRUE);
2415 printf("%s: Issued Channel %c Bus Reset. "
2416 "%d SCBs aborted\n", ahd_name(ahd), 'A', found);
2417 } else {
2418 /*
2419 * Leave the selection hardware off in case
2420 * this abort attempt will affect yet to
2421 * be sent commands.
2422 */
2423 ahd_outb(ahd, SCSISEQ0,
2424 ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
2425 ahd_assert_atn(ahd);
2426 ahd_outb(ahd, MSG_OUT, HOST_MSG);
2427 if (scb == NULL) {
2428 ahd_print_devinfo(ahd, &devinfo);
2429 ahd->msgout_buf[0] = MSG_ABORT_TASK;
2430 ahd->msgout_len = 1;
2431 ahd->msgout_index = 0;
2432 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
2433 } else {
2434 ahd_print_path(ahd, scb);
2435 scb->flags |= SCB_ABORT;
2436 }
2437 printf("Protocol violation %s. Attempting to abort.\n",
2438 ahd_lookup_phase_entry(curphase)->phasemsg);
2439 }
2440 }
2441
2442 /*
2443 * Force renegotiation to occur the next time we initiate
2444 * a command to the current device.
2445 */
2446 static void
2447 ahd_force_renegotiation(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
2448 {
2449 struct ahd_initiator_tinfo *targ_info;
2450 struct ahd_tmode_tstate *tstate;
2451
2452 #ifdef AHD_DEBUG
2453 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
2454 ahd_print_devinfo(ahd, devinfo);
2455 printf("Forcing renegotiation\n");
2456 }
2457 #endif
2458 targ_info = ahd_fetch_transinfo(ahd,
2459 devinfo->channel,
2460 devinfo->our_scsiid,
2461 devinfo->target,
2462 &tstate);
2463 ahd_update_neg_request(ahd, devinfo, tstate,
2464 targ_info, AHD_NEG_IF_NON_ASYNC);
2465 }
2466
2467 #define AHD_MAX_STEPS 2000
2468 void
2469 ahd_clear_critical_section(struct ahd_softc *ahd)
2470 {
2471 ahd_mode_state saved_modes;
2472 int stepping;
2473 int steps;
2474 int first_instr;
2475 u_int simode0;
2476 u_int simode1;
2477 u_int simode3;
2478 u_int lqimode0;
2479 u_int lqimode1;
2480 u_int lqomode0;
2481 u_int lqomode1;
2482
2483 if (ahd->num_critical_sections == 0)
2484 return;
2485
2486 stepping = FALSE;
2487 steps = 0;
2488 first_instr = 0;
2489 simode0 = 0;
2490 simode1 = 0;
2491 simode3 = 0;
2492 lqimode0 = 0;
2493 lqimode1 = 0;
2494 lqomode0 = 0;
2495 lqomode1 = 0;
2496 saved_modes = ahd_save_modes(ahd);
2497 for (;;) {
2498 struct cs *cs;
2499 u_int seqaddr;
2500 u_int i;
2501
2502 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
2503 seqaddr = ahd_inb(ahd, CURADDR)
2504 | (ahd_inb(ahd, CURADDR+1) << 8);
2505
2506 cs = ahd->critical_sections;
2507 for (i = 0; i < ahd->num_critical_sections; i++, cs++) {
2508
2509 if (cs->begin < seqaddr && cs->end >= seqaddr)
2510 break;
2511 }
2512
2513 if (i == ahd->num_critical_sections)
2514 break;
2515
2516 if (steps > AHD_MAX_STEPS) {
2517 printf("%s: Infinite loop in critical section\n"
2518 "%s: First Instruction 0x%x now 0x%x\n",
2519 ahd_name(ahd), ahd_name(ahd), first_instr,
2520 seqaddr);
2521 ahd_dump_card_state(ahd);
2522 panic("critical section loop");
2523 }
2524
2525 steps++;
2526 #ifdef AHD_DEBUG
2527 if ((ahd_debug & AHD_SHOW_MISC) != 0)
2528 printf("%s: Single stepping at 0x%x\n", ahd_name(ahd),
2529 seqaddr);
2530 #endif
2531 if (stepping == FALSE) {
2532
2533 first_instr = seqaddr;
2534 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
2535 simode0 = ahd_inb(ahd, SIMODE0);
2536 simode3 = ahd_inb(ahd, SIMODE3);
2537 lqimode0 = ahd_inb(ahd, LQIMODE0);
2538 lqimode1 = ahd_inb(ahd, LQIMODE1);
2539 lqomode0 = ahd_inb(ahd, LQOMODE0);
2540 lqomode1 = ahd_inb(ahd, LQOMODE1);
2541 ahd_outb(ahd, SIMODE0, 0);
2542 ahd_outb(ahd, SIMODE3, 0);
2543 ahd_outb(ahd, LQIMODE0, 0);
2544 ahd_outb(ahd, LQIMODE1, 0);
2545 ahd_outb(ahd, LQOMODE0, 0);
2546 ahd_outb(ahd, LQOMODE1, 0);
2547 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
2548 simode1 = ahd_inb(ahd, SIMODE1);
2549 /*
2550 * We don't clear ENBUSFREE. Unfortunately
2551 * we cannot re-enable busfree detection within
2552 * the current connection, so we must leave it
2553 * on while single stepping.
2554 */
2555 ahd_outb(ahd, SIMODE1, simode1 & ENBUSFREE);
2556 ahd_outb(ahd, SEQCTL0, ahd_inb(ahd, SEQCTL0) | STEP);
2557 stepping = TRUE;
2558 }
2559 ahd_outb(ahd, CLRSINT1, CLRBUSFREE);
2560 ahd_outb(ahd, CLRINT, CLRSCSIINT);
2561 ahd_set_modes(ahd, ahd->saved_src_mode, ahd->saved_dst_mode);
2562 ahd_outb(ahd, HCNTRL, ahd->unpause);
2563 while (!ahd_is_paused(ahd))
2564 ahd_delay(200);
2565 ahd_update_modes(ahd);
2566 }
2567 if (stepping) {
2568 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
2569 ahd_outb(ahd, SIMODE0, simode0);
2570 ahd_outb(ahd, SIMODE3, simode3);
2571 ahd_outb(ahd, LQIMODE0, lqimode0);
2572 ahd_outb(ahd, LQIMODE1, lqimode1);
2573 ahd_outb(ahd, LQOMODE0, lqomode0);
2574 ahd_outb(ahd, LQOMODE1, lqomode1);
2575 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
2576 ahd_outb(ahd, SEQCTL0, ahd_inb(ahd, SEQCTL0) & ~STEP);
2577 ahd_outb(ahd, SIMODE1, simode1);
2578 /*
2579 * SCSIINT seems to glitch occassionally when
2580 * the interrupt masks are restored. Clear SCSIINT
2581 * one more time so that only persistent errors
2582 * are seen as a real interrupt.
2583 */
2584 ahd_outb(ahd, CLRINT, CLRSCSIINT);
2585 }
2586 ahd_restore_modes(ahd, saved_modes);
2587 }
2588
2589 /*
2590 * Clear any pending interrupt status.
2591 */
2592 void
2593 ahd_clear_intstat(struct ahd_softc *ahd)
2594 {
2595 AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
2596 ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
2597 /* Clear any interrupt conditions this may have caused */
2598 ahd_outb(ahd, CLRLQIINT0, CLRLQIATNQAS|CLRLQICRCT1|CLRLQICRCT2
2599 |CLRLQIBADLQT|CLRLQIATNLQ|CLRLQIATNCMD);
2600 ahd_outb(ahd, CLRLQIINT1, CLRLQIPHASE_LQ|CLRLQIPHASE_NLQ|CLRLIQABORT
2601 |CLRLQICRCI_LQ|CLRLQICRCI_NLQ|CLRLQIBADLQI
2602 |CLRLQIOVERI_LQ|CLRLQIOVERI_NLQ|CLRNONPACKREQ);
2603 ahd_outb(ahd, CLRLQOINT0, CLRLQOTARGSCBPERR|CLRLQOSTOPT2|CLRLQOATNLQ
2604 |CLRLQOATNPKT|CLRLQOTCRC);
2605 ahd_outb(ahd, CLRLQOINT1, CLRLQOINITSCBPERR|CLRLQOSTOPI2|CLRLQOBADQAS
2606 |CLRLQOBUSFREE|CLRLQOPHACHGINPKT);
2607 if ((ahd->bugs & AHD_CLRLQO_AUTOCLR_BUG) != 0) {
2608 ahd_outb(ahd, CLRLQOINT0, 0);
2609 ahd_outb(ahd, CLRLQOINT1, 0);
2610 }
2611 ahd_outb(ahd, CLRSINT3, CLRNTRAMPERR|CLROSRAMPERR);
2612 ahd_outb(ahd, CLRSINT1, CLRSELTIMEO|CLRATNO|CLRSCSIRSTI
2613 |CLRBUSFREE|CLRSCSIPERR|CLRREQINIT);
2614 ahd_outb(ahd, CLRSINT0, CLRSELDO|CLRSELDI|CLRSELINGO
2615 |CLRIOERR|CLROVERRUN);
2616 ahd_outb(ahd, CLRINT, CLRSCSIINT);
2617 }
2618
2619 /**************************** Debugging Routines ******************************/
2620 #ifdef AHD_DEBUG
2621 uint32_t ahd_debug = AHD_DEBUG_OPTS;
2622 #endif
2623 void
2624 ahd_print_scb(struct scb *scb)
2625 {
2626 struct hardware_scb *hscb;
2627 int i;
2628
2629 hscb = scb->hscb;
2630 printf("scb:%p control:0x%x scsiid:0x%x lun:%d cdb_len:%d\n",
2631 (void *)scb,
2632 hscb->control,
2633 hscb->scsiid,
2634 hscb->lun,
2635 hscb->cdb_len);
2636 printf("Shared Data: ");
2637 for (i = 0; i < sizeof(hscb->shared_data.idata.cdb); i++)
2638 printf("%#02x", hscb->shared_data.idata.cdb[i]);
2639 printf(" dataptr:%#x%x datacnt:%#x sgptr:%#x tag:%#x\n",
2640 (uint32_t)((ahd_le64toh(hscb->dataptr) >> 32) & 0xFFFFFFFF),
2641 (uint32_t)(ahd_le64toh(hscb->dataptr) & 0xFFFFFFFF),
2642 ahd_le32toh(hscb->datacnt),
2643 ahd_le32toh(hscb->sgptr),
2644 SCB_GET_TAG(scb));
2645 ahd_dump_sglist(scb);
2646 }
2647
2648 void
2649 ahd_dump_sglist(struct scb *scb)
2650 {
2651 int i;
2652
2653 if (scb->sg_count > 0) {
2654 if ((scb->ahd_softc->flags & AHD_64BIT_ADDRESSING) != 0) {
2655 struct ahd_dma64_seg *sg_list;
2656
2657 sg_list = (struct ahd_dma64_seg*)scb->sg_list;
2658 for (i = 0; i < scb->sg_count; i++) {
2659 uint64_t addr;
2660 uint32_t len;
2661
2662 addr = ahd_le64toh(sg_list[i].addr);
2663 len = ahd_le32toh(sg_list[i].len);
2664 printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
2665 i,
2666 (uint32_t)((addr >> 32) & 0xFFFFFFFF),
2667 (uint32_t)(addr & 0xFFFFFFFF),
2668 sg_list[i].len & AHD_SG_LEN_MASK,
2669 (sg_list[i].len & AHD_DMA_LAST_SEG)
2670 ? " Last" : "");
2671 }
2672 } else {
2673 struct ahd_dma_seg *sg_list;
2674
2675 sg_list = (struct ahd_dma_seg*)scb->sg_list;
2676 for (i = 0; i < scb->sg_count; i++) {
2677 uint32_t len;
2678
2679 len = ahd_le32toh(sg_list[i].len);
2680 printf("sg[%d] - Addr 0x%x%x : Length %d%s\n",
2681 i,
2682 (len & AHD_SG_HIGH_ADDR_MASK) >> 24,
2683 ahd_le32toh(sg_list[i].addr),
2684 len & AHD_SG_LEN_MASK,
2685 len & AHD_DMA_LAST_SEG ? " Last" : "");
2686 }
2687 }
2688 }
2689 }
2690
2691 /************************* Transfer Negotiation *******************************/
2692 /*
2693 * Allocate per target mode instance (ID we respond to as a target)
2694 * transfer negotiation data structures.
2695 */
2696 static struct ahd_tmode_tstate *
2697 ahd_alloc_tstate(struct ahd_softc *ahd, u_int scsi_id, char channel)
2698 {
2699 struct ahd_tmode_tstate *master_tstate;
2700 struct ahd_tmode_tstate *tstate;
2701 int i;
2702
2703 master_tstate = ahd->enabled_targets[ahd->our_id];
2704 if (ahd->enabled_targets[scsi_id] != NULL
2705 && ahd->enabled_targets[scsi_id] != master_tstate)
2706 panic("%s: ahd_alloc_tstate - Target already allocated",
2707 ahd_name(ahd));
2708 tstate = malloc(sizeof(*tstate), M_DEVBUF, M_NOWAIT | M_ZERO);
2709 if (tstate == NULL)
2710 return (NULL);
2711
2712 /*
2713 * If we have allocated a master tstate, copy user settings from
2714 * the master tstate (taken from SRAM or the EEPROM) for this
2715 * channel, but reset our current and goal settings to async/narrow
2716 * until an initiator talks to us.
2717 */
2718 if (master_tstate != NULL) {
2719 memcpy(tstate, master_tstate, sizeof(*tstate));
2720 memset(tstate->enabled_luns, 0, sizeof(tstate->enabled_luns));
2721 for (i = 0; i < 16; i++) {
2722 memset(&tstate->transinfo[i].curr, 0,
2723 sizeof(tstate->transinfo[i].curr));
2724 memset(&tstate->transinfo[i].goal, 0,
2725 sizeof(tstate->transinfo[i].goal));
2726 }
2727 } else
2728 memset(tstate, 0, sizeof(*tstate));
2729 ahd->enabled_targets[scsi_id] = tstate;
2730 return (tstate);
2731 }
2732
2733 #ifdef AHD_TARGET_MODE
2734 /*
2735 * Free per target mode instance (ID we respond to as a target)
2736 * transfer negotiation data structures.
2737 */
2738 static void
2739 ahd_free_tstate(struct ahd_softc *ahd, u_int scsi_id, char channel, int force)
2740 {
2741 struct ahd_tmode_tstate *tstate;
2742
2743 /*
2744 * Don't clean up our "master" tstate.
2745 * It has our default user settings.
2746 */
2747 if (scsi_id == ahd->our_id
2748 && force == FALSE)
2749 return;
2750
2751 tstate = ahd->enabled_targets[scsi_id];
2752 if (tstate != NULL)
2753 free(tstate, M_DEVBUF);
2754 ahd->enabled_targets[scsi_id] = NULL;
2755 }
2756 #endif
2757
2758 /*
2759 * Called when we have an active connection to a target on the bus,
2760 * this function finds the nearest period to the input period limited
2761 * by the capabilities of the bus connectivity of and sync settings for
2762 * the target.
2763 */
2764 void
2765 ahd_devlimited_syncrate(struct ahd_softc *ahd,
2766 struct ahd_initiator_tinfo *tinfo,
2767 u_int *period, u_int *ppr_options, role_t role)
2768 {
2769 struct ahd_transinfo *transinfo;
2770 u_int maxsync;
2771
2772 if ((ahd_inb(ahd, SBLKCTL) & ENAB40) != 0
2773 && (ahd_inb(ahd, SSTAT2) & EXP_ACTIVE) == 0) {
2774 maxsync = AHD_SYNCRATE_PACED;
2775 } else {
2776 maxsync = AHD_SYNCRATE_ULTRA;
2777 /* Can't do DT related options on an SE bus */
2778 *ppr_options &= MSG_EXT_PPR_QAS_REQ;
2779 }
2780 /*
2781 * Never allow a value higher than our current goal
2782 * period otherwise we may allow a target initiated
2783 * negotiation to go above the limit as set by the
2784 * user. In the case of an initiator initiated
2785 * sync negotiation, we limit based on the user
2786 * setting. This allows the system to still accept
2787 * incoming negotiations even if target initiated
2788 * negotiation is not performed.
2789 */
2790 if (role == ROLE_TARGET)
2791 transinfo = &tinfo->user;
2792 else
2793 transinfo = &tinfo->goal;
2794 *ppr_options &= (transinfo->ppr_options|MSG_EXT_PPR_PCOMP_EN);
2795 if (transinfo->width == MSG_EXT_WDTR_BUS_8_BIT) {
2796 maxsync = MAX(maxsync, AHD_SYNCRATE_ULTRA2);
2797 *ppr_options &= ~MSG_EXT_PPR_DT_REQ;
2798 }
2799 if (transinfo->period == 0) {
2800 *period = 0;
2801 *ppr_options = 0;
2802 } else {
2803 *period = MAX(*period, transinfo->period);
2804 ahd_find_syncrate(ahd, period, ppr_options, maxsync);
2805 }
2806 }
2807
2808 /*
2809 * Look up the valid period to SCSIRATE conversion in our table.
2810 * Return the period and offset that should be sent to the target
2811 * if this was the beginning of an SDTR.
2812 */
2813 void
2814 ahd_find_syncrate(struct ahd_softc *ahd, u_int *period,
2815 u_int *ppr_options, u_int maxsync)
2816 {
2817 if (*period < maxsync)
2818 *period = maxsync;
2819
2820 if ((*ppr_options & MSG_EXT_PPR_DT_REQ) != 0
2821 && *period > AHD_SYNCRATE_MIN_DT)
2822 *ppr_options &= ~MSG_EXT_PPR_DT_REQ;
2823
2824 if (*period > AHD_SYNCRATE_MIN)
2825 *period = 0;
2826
2827 /* Honor PPR option conformance rules. */
2828 if (*period > AHD_SYNCRATE_PACED)
2829 *ppr_options &= ~MSG_EXT_PPR_RTI;
2830
2831 if ((*ppr_options & MSG_EXT_PPR_IU_REQ) == 0)
2832 *ppr_options &= (MSG_EXT_PPR_DT_REQ|MSG_EXT_PPR_QAS_REQ);
2833
2834 if ((*ppr_options & MSG_EXT_PPR_DT_REQ) == 0)
2835 *ppr_options &= MSG_EXT_PPR_QAS_REQ;
2836
2837 /* Skip all PACED only entries if IU is not available */
2838 if ((*ppr_options & MSG_EXT_PPR_IU_REQ) == 0
2839 && *period < AHD_SYNCRATE_DT)
2840 *period = AHD_SYNCRATE_DT;
2841
2842 /* Skip all DT only entries if DT is not available */
2843 if ((*ppr_options & MSG_EXT_PPR_DT_REQ) == 0
2844 && *period < AHD_SYNCRATE_ULTRA2)
2845 *period = AHD_SYNCRATE_ULTRA2;
2846 }
2847
2848 /*
2849 * Truncate the given synchronous offset to a value the
2850 * current adapter type and syncrate are capable of.
2851 */
2852 void
2853 ahd_validate_offset(struct ahd_softc *ahd,
2854 struct ahd_initiator_tinfo *tinfo,
2855 u_int period, u_int *offset, int wide,
2856 role_t role)
2857 {
2858 u_int maxoffset;
2859
2860 /* Limit offset to what we can do */
2861 if (period == 0)
2862 maxoffset = 0;
2863 else if (period <= AHD_SYNCRATE_PACED) {
2864 if ((ahd->bugs & AHD_PACED_NEGTABLE_BUG) != 0)
2865 maxoffset = MAX_OFFSET_PACED_BUG;
2866 else
2867 maxoffset = MAX_OFFSET_PACED;
2868 } else
2869 maxoffset = MAX_OFFSET_NON_PACED;
2870 *offset = MIN(*offset, maxoffset);
2871 if (tinfo != NULL) {
2872 if (role == ROLE_TARGET)
2873 *offset = MIN(*offset, tinfo->user.offset);
2874 else
2875 *offset = MIN(*offset, tinfo->goal.offset);
2876 }
2877 }
2878
2879 /*
2880 * Truncate the given transfer width parameter to a value the
2881 * current adapter type is capable of.
2882 */
2883 void
2884 ahd_validate_width(struct ahd_softc *ahd, struct ahd_initiator_tinfo *tinfo,
2885 u_int *bus_width, role_t role)
2886 {
2887 switch (*bus_width) {
2888 default:
2889 if (ahd->features & AHD_WIDE) {
2890 /* Respond Wide */
2891 *bus_width = MSG_EXT_WDTR_BUS_16_BIT;
2892 break;
2893 }
2894 /* FALLTHROUGH */
2895 case MSG_EXT_WDTR_BUS_8_BIT:
2896 *bus_width = MSG_EXT_WDTR_BUS_8_BIT;
2897 break;
2898 }
2899 if (tinfo != NULL) {
2900 if (role == ROLE_TARGET)
2901 *bus_width = MIN(tinfo->user.width, *bus_width);
2902 else
2903 *bus_width = MIN(tinfo->goal.width, *bus_width);
2904 }
2905 }
2906
2907 /*
2908 * Update the bitmask of targets for which the controller should
2909 * negotiate with at the next convenient opportunity. This currently
2910 * means the next time we send the initial identify messages for
2911 * a new transaction.
2912 */
2913 int
2914 ahd_update_neg_request(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
2915 struct ahd_tmode_tstate *tstate,
2916 struct ahd_initiator_tinfo *tinfo, ahd_neg_type neg_type)
2917 {
2918 u_int auto_negotiate_orig;
2919
2920 auto_negotiate_orig = tstate->auto_negotiate;
2921 if (neg_type == AHD_NEG_ALWAYS) {
2922 /*
2923 * Force our "current" settings to be
2924 * unknown so that unless a bus reset
2925 * occurs the need to renegotiate is
2926 * recorded persistently.
2927 */
2928 if ((ahd->features & AHD_WIDE) != 0)
2929 tinfo->curr.width = AHD_WIDTH_UNKNOWN;
2930 tinfo->curr.period = AHD_PERIOD_UNKNOWN;
2931 tinfo->curr.offset = AHD_OFFSET_UNKNOWN;
2932 }
2933 if (tinfo->curr.period != tinfo->goal.period
2934 || tinfo->curr.width != tinfo->goal.width
2935 || tinfo->curr.offset != tinfo->goal.offset
2936 || tinfo->curr.ppr_options != tinfo->goal.ppr_options
2937 || (neg_type == AHD_NEG_IF_NON_ASYNC
2938 && (tinfo->goal.offset != 0
2939 || tinfo->goal.width != MSG_EXT_WDTR_BUS_8_BIT
2940 || tinfo->goal.ppr_options != 0)))
2941 tstate->auto_negotiate |= devinfo->target_mask;
2942 else
2943 tstate->auto_negotiate &= ~devinfo->target_mask;
2944
2945 return (auto_negotiate_orig != tstate->auto_negotiate);
2946 }
2947
2948 /*
2949 * Update the user/goal/curr tables of synchronous negotiation
2950 * parameters as well as, in the case of a current or active update,
2951 * any data structures on the host controller. In the case of an
2952 * active update, the specified target is currently talking to us on
2953 * the bus, so the transfer parameter update must take effect
2954 * immediately.
2955 */
2956 void
2957 ahd_set_syncrate(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
2958 u_int period, u_int offset, u_int ppr_options,
2959 u_int type, int paused)
2960 {
2961 struct ahd_initiator_tinfo *tinfo;
2962 struct ahd_tmode_tstate *tstate;
2963 u_int old_period;
2964 u_int old_offset;
2965 u_int old_ppr;
2966 int active;
2967 int update_needed;
2968
2969 active = (type & AHD_TRANS_ACTIVE) == AHD_TRANS_ACTIVE;
2970 update_needed = 0;
2971
2972 if (period == 0 || offset == 0) {
2973 period = 0;
2974 offset = 0;
2975 }
2976
2977 tinfo = ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
2978 devinfo->target, &tstate);
2979
2980 if ((type & AHD_TRANS_USER) != 0) {
2981 tinfo->user.period = period;
2982 tinfo->user.offset = offset;
2983 tinfo->user.ppr_options = ppr_options;
2984 }
2985
2986 if ((type & AHD_TRANS_GOAL) != 0) {
2987 tinfo->goal.period = period;
2988 tinfo->goal.offset = offset;
2989 tinfo->goal.ppr_options = ppr_options;
2990 }
2991
2992 old_period = tinfo->curr.period;
2993 old_offset = tinfo->curr.offset;
2994 old_ppr = tinfo->curr.ppr_options;
2995
2996 if ((type & AHD_TRANS_CUR) != 0
2997 && (old_period != period
2998 || old_offset != offset
2999 || old_ppr != ppr_options)) {
3000
3001 update_needed++;
3002
3003 tinfo->curr.period = period;
3004 tinfo->curr.offset = offset;
3005 tinfo->curr.ppr_options = ppr_options;
3006
3007 ahd_send_async(ahd, devinfo->channel, devinfo->target,
3008 CAM_LUN_WILDCARD, AC_TRANSFER_NEG, NULL);
3009
3010 if (bootverbose) {
3011 if (offset != 0) {
3012 int options;
3013
3014 printf("%s: target %d synchronous with "
3015 "period = 0x%x, offset = 0x%x",
3016 ahd_name(ahd), devinfo->target,
3017 period, offset);
3018 options = 0;
3019 if ((ppr_options & MSG_EXT_PPR_RD_STRM) != 0) {
3020 printf("(RDSTRM");
3021 options++;
3022 }
3023 if ((ppr_options & MSG_EXT_PPR_DT_REQ) != 0) {
3024 printf("%s", options ? "|DT" : "(DT");
3025 options++;
3026 }
3027 if ((ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
3028 printf("%s", options ? "|IU" : "(IU");
3029 options++;
3030 }
3031 if ((ppr_options & MSG_EXT_PPR_RTI) != 0) {
3032 printf("%s", options ? "|RTI" : "(RTI");
3033 options++;
3034 }
3035 if ((ppr_options & MSG_EXT_PPR_QAS_REQ) != 0) {
3036 printf("%s", options ? "|QAS" : "(QAS");
3037 options++;
3038 }
3039 if (options != 0)
3040 printf(")\n");
3041 else
3042 printf("\n");
3043 } else {
3044 printf("%s: target %d using "
3045 "asynchronous transfers%s\n",
3046 ahd_name(ahd), devinfo->target,
3047 (ppr_options & MSG_EXT_PPR_QAS_REQ) != 0
3048 ? "(QAS)" : "");
3049 }
3050 }
3051 }
3052 /*
3053 * Always refresh the neg-table to handle the case of the
3054 * sequencer setting the ENATNO bit for a MK_MESSAGE request.
3055 * We will always renegotiate in that case if this is a
3056 * packetized request. Also manage the busfree expected flag
3057 * from this common routine so that we catch changes due to
3058 * WDTR or SDTR messages.
3059 */
3060 if ((type & AHD_TRANS_CUR) != 0) {
3061 if (!paused)
3062 ahd_pause(ahd);
3063 ahd_update_neg_table(ahd, devinfo, &tinfo->curr);
3064 if (!paused)
3065 ahd_unpause(ahd);
3066 if (ahd->msg_type != MSG_TYPE_NONE) {
3067 if ((old_ppr & MSG_EXT_PPR_IU_REQ)
3068 != (ppr_options & MSG_EXT_PPR_IU_REQ)) {
3069 #ifdef AHD_DEBUG
3070 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3071 ahd_print_devinfo(ahd, devinfo);
3072 printf("Expecting IU Change busfree\n");
3073 }
3074 #endif
3075 ahd->msg_flags |= MSG_FLAG_EXPECT_PPR_BUSFREE
3076 | MSG_FLAG_IU_REQ_CHANGED;
3077 }
3078 if ((old_ppr & MSG_EXT_PPR_IU_REQ) != 0) {
3079 #ifdef AHD_DEBUG
3080 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
3081 printf("PPR with IU_REQ outstanding\n");
3082 #endif
3083 ahd->msg_flags |= MSG_FLAG_EXPECT_PPR_BUSFREE;
3084 }
3085 }
3086 }
3087
3088 update_needed += ahd_update_neg_request(ahd, devinfo, tstate,
3089 tinfo, AHD_NEG_TO_GOAL);
3090
3091 if (update_needed && active)
3092 ahd_update_pending_scbs(ahd);
3093 }
3094
3095 /*
3096 * Update the user/goal/curr tables of wide negotiation
3097 * parameters as well as, in the case of a current or active update,
3098 * any data structures on the host controller. In the case of an
3099 * active update, the specified target is currently talking to us on
3100 * the bus, so the transfer parameter update must take effect
3101 * immediately.
3102 */
3103 void
3104 ahd_set_width(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3105 u_int width, u_int type, int paused)
3106 {
3107 struct ahd_initiator_tinfo *tinfo;
3108 struct ahd_tmode_tstate *tstate;
3109 u_int oldwidth;
3110 int active;
3111 int update_needed;
3112
3113 active = (type & AHD_TRANS_ACTIVE) == AHD_TRANS_ACTIVE;
3114 update_needed = 0;
3115 tinfo = ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
3116 devinfo->target, &tstate);
3117
3118 if ((type & AHD_TRANS_USER) != 0)
3119 tinfo->user.width = width;
3120
3121 if ((type & AHD_TRANS_GOAL) != 0)
3122 tinfo->goal.width = width;
3123
3124 oldwidth = tinfo->curr.width;
3125 if ((type & AHD_TRANS_CUR) != 0 && oldwidth != width) {
3126
3127 update_needed++;
3128
3129 tinfo->curr.width = width;
3130 ahd_send_async(ahd, devinfo->channel, devinfo->target,
3131 CAM_LUN_WILDCARD, AC_TRANSFER_NEG, NULL);
3132
3133 if (bootverbose) {
3134 printf("%s: target %d using %dbit transfers\n",
3135 ahd_name(ahd), devinfo->target,
3136 8 * (0x01 << width));
3137 }
3138 }
3139
3140 if ((type & AHD_TRANS_CUR) != 0) {
3141 if (!paused)
3142 ahd_pause(ahd);
3143 ahd_update_neg_table(ahd, devinfo, &tinfo->curr);
3144 if (!paused)
3145 ahd_unpause(ahd);
3146 }
3147
3148 update_needed += ahd_update_neg_request(ahd, devinfo, tstate,
3149 tinfo, AHD_NEG_TO_GOAL);
3150 if (update_needed && active)
3151 ahd_update_pending_scbs(ahd);
3152
3153 }
3154
3155 /*
3156 * Update the current state of tagged queuing for a given target.
3157 */
3158 void
3159 ahd_set_tags(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3160 ahd_queue_alg alg)
3161 {
3162 ahd_platform_set_tags(ahd, devinfo, alg);
3163 ahd_send_async(ahd, devinfo->channel, devinfo->target,
3164 devinfo->lun, AC_TRANSFER_NEG, &alg);
3165 }
3166
3167 static void
3168 ahd_update_neg_table(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3169 struct ahd_transinfo *tinfo)
3170 {
3171 ahd_mode_state saved_modes;
3172 u_int period;
3173 u_int ppr_opts;
3174 u_int con_opts;
3175 u_int offset;
3176 u_int saved_negoaddr;
3177 uint8_t iocell_opts[sizeof(ahd->iocell_opts)];
3178
3179 saved_modes = ahd_save_modes(ahd);
3180 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
3181
3182 saved_negoaddr = ahd_inb(ahd, NEGOADDR);
3183 ahd_outb(ahd, NEGOADDR, devinfo->target);
3184 period = tinfo->period;
3185 offset = tinfo->offset;
3186 memcpy(iocell_opts, ahd->iocell_opts, sizeof(ahd->iocell_opts));
3187 ppr_opts = tinfo->ppr_options & (MSG_EXT_PPR_QAS_REQ|MSG_EXT_PPR_DT_REQ
3188 |MSG_EXT_PPR_IU_REQ|MSG_EXT_PPR_RTI);
3189 con_opts = 0;
3190 if (period == 0)
3191 period = AHD_SYNCRATE_ASYNC;
3192 if (period == AHD_SYNCRATE_160) {
3193
3194 if ((ahd->bugs & AHD_PACED_NEGTABLE_BUG) != 0) {
3195 /*
3196 * When the SPI4 spec was finalized, PACE transfers
3197 * was not made a configurable option in the PPR
3198 * message. Instead it is assumed to be enabled for
3199 * any syncrate faster than 80MHz. Nevertheless,
3200 * Harpoon2A4 allows this to be configurable.
3201 *
3202 * Harpoon2A4 also assumes at most 2 data bytes per
3203 * negotiated REQ/ACK offset. Paced transfers take
3204 * 4, so we must adjust our offset.
3205 */
3206 ppr_opts |= PPROPT_PACE;
3207 offset *= 2;
3208
3209 /*
3210 * Harpoon2A assumed that there would be a
3211 * fallback rate between 160 MHz and 80 MHz,
3212 * so 7 is used as the period factor rather
3213 * than 8 for 160MHz.
3214 */
3215 period = AHD_SYNCRATE_REVA_160;
3216 }
3217 if ((tinfo->ppr_options & MSG_EXT_PPR_PCOMP_EN) == 0)
3218 iocell_opts[AHD_PRECOMP_SLEW_INDEX] &=
3219 ~AHD_PRECOMP_MASK;
3220 } else {
3221 /*
3222 * Precomp should be disabled for non-paced transfers.
3223 */
3224 iocell_opts[AHD_PRECOMP_SLEW_INDEX] &= ~AHD_PRECOMP_MASK;
3225
3226 if ((ahd->features & AHD_NEW_IOCELL_OPTS) != 0
3227 && (ppr_opts & MSG_EXT_PPR_DT_REQ) != 0) {
3228 /*
3229 * Slow down our CRC interval to be
3230 * compatible with devices that can't
3231 * handle a CRC at full speed.
3232 */
3233 con_opts |= ENSLOWCRC;
3234 }
3235 }
3236
3237 ahd_outb(ahd, ANNEXCOL, AHD_ANNEXCOL_PRECOMP_SLEW);
3238 ahd_outb(ahd, ANNEXDAT, iocell_opts[AHD_PRECOMP_SLEW_INDEX]);
3239 ahd_outb(ahd, ANNEXCOL, AHD_ANNEXCOL_AMPLITUDE);
3240 ahd_outb(ahd, ANNEXDAT, iocell_opts[AHD_AMPLITUDE_INDEX]);
3241
3242 ahd_outb(ahd, NEGPERIOD, period);
3243 ahd_outb(ahd, NEGPPROPTS, ppr_opts);
3244 ahd_outb(ahd, NEGOFFSET, offset);
3245
3246 if (tinfo->width == MSG_EXT_WDTR_BUS_16_BIT)
3247 con_opts |= WIDEXFER;
3248
3249 /*
3250 * During packetized transfers, the target will
3251 * give us the opportunity to send command packets
3252 * without us asserting attention.
3253 */
3254 if ((tinfo->ppr_options & MSG_EXT_PPR_IU_REQ) == 0)
3255 con_opts |= ENAUTOATNO;
3256 ahd_outb(ahd, NEGCONOPTS, con_opts);
3257 ahd_outb(ahd, NEGOADDR, saved_negoaddr);
3258 ahd_restore_modes(ahd, saved_modes);
3259 }
3260
3261 /*
3262 * When the transfer settings for a connection change, setup for
3263 * negotiation in pending SCBs to effect the change as quickly as
3264 * possible. We also cancel any negotiations that are scheduled
3265 * for inflight SCBs that have not been started yet.
3266 */
3267 static void
3268 ahd_update_pending_scbs(struct ahd_softc *ahd)
3269 {
3270 struct scb *pending_scb;
3271 int pending_scb_count;
3272 u_int scb_tag;
3273 int paused;
3274 u_int saved_scbptr;
3275 ahd_mode_state saved_modes;
3276
3277 /*
3278 * Traverse the pending SCB list and ensure that all of the
3279 * SCBs there have the proper settings. We can only safely
3280 * clear the negotiation required flag (setting requires the
3281 * execution queue to be modified) and this is only possible
3282 * if we are not already attempting to select out for this
3283 * SCB. For this reason, all callers only call this routine
3284 * if we are changing the negotiation settings for the currently
3285 * active transaction on the bus.
3286 */
3287 pending_scb_count = 0;
3288 LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
3289 struct ahd_devinfo devinfo;
3290 struct hardware_scb *pending_hscb;
3291 struct ahd_initiator_tinfo *tinfo;
3292 struct ahd_tmode_tstate *tstate;
3293
3294 ahd_scb_devinfo(ahd, &devinfo, pending_scb);
3295 tinfo = ahd_fetch_transinfo(ahd, devinfo.channel,
3296 devinfo.our_scsiid,
3297 devinfo.target, &tstate);
3298 pending_hscb = pending_scb->hscb;
3299 if ((tstate->auto_negotiate & devinfo.target_mask) == 0
3300 && (pending_scb->flags & SCB_AUTO_NEGOTIATE) != 0) {
3301 pending_scb->flags &= ~SCB_AUTO_NEGOTIATE;
3302 pending_hscb->control &= ~MK_MESSAGE;
3303 }
3304 ahd_sync_scb(ahd, pending_scb,
3305 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
3306 pending_scb_count++;
3307 }
3308
3309 if (pending_scb_count == 0)
3310 return;
3311
3312 if (ahd_is_paused(ahd)) {
3313 paused = 1;
3314 } else {
3315 paused = 0;
3316 ahd_pause(ahd);
3317 }
3318
3319 /*
3320 * Force the sequencer to reinitialize the selection for
3321 * the command at the head of the execution queue if it
3322 * has already been setup. The negotiation changes may
3323 * effect whether we select-out with ATN.
3324 */
3325 saved_modes = ahd_save_modes(ahd);
3326 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
3327 ahd_outb(ahd, SCSISEQ0, ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
3328 saved_scbptr = ahd_get_scbptr(ahd);
3329 /* Ensure that the hscbs down on the card match the new information */
3330 for (scb_tag = 0; scb_tag < ahd->scb_data.maxhscbs; scb_tag++) {
3331 struct hardware_scb *pending_hscb;
3332 u_int control;
3333
3334 pending_scb = ahd_lookup_scb(ahd, scb_tag);
3335 if (pending_scb == NULL)
3336 continue;
3337 ahd_set_scbptr(ahd, scb_tag);
3338 pending_hscb = pending_scb->hscb;
3339 control = ahd_inb_scbram(ahd, SCB_CONTROL);
3340 control &= ~MK_MESSAGE;
3341 control |= pending_hscb->control & MK_MESSAGE;
3342 ahd_outb(ahd, SCB_CONTROL, control);
3343 }
3344 ahd_set_scbptr(ahd, saved_scbptr);
3345 ahd_restore_modes(ahd, saved_modes);
3346
3347 if (paused == 0)
3348 ahd_unpause(ahd);
3349 }
3350
3351 /**************************** Pathing Information *****************************/
3352 static void
3353 ahd_fetch_devinfo(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
3354 {
3355 ahd_mode_state saved_modes;
3356 u_int saved_scsiid;
3357 role_t role;
3358 int our_id;
3359
3360 saved_modes = ahd_save_modes(ahd);
3361 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
3362
3363 if (ahd_inb(ahd, SSTAT0) & TARGET)
3364 role = ROLE_TARGET;
3365 else
3366 role = ROLE_INITIATOR;
3367
3368 if (role == ROLE_TARGET
3369 && (ahd_inb(ahd, SEQ_FLAGS) & CMDPHASE_PENDING) != 0) {
3370 /* We were selected, so pull our id from TARGIDIN */
3371 our_id = ahd_inb(ahd, TARGIDIN) & OID;
3372 } else if (role == ROLE_TARGET)
3373 our_id = ahd_inb(ahd, TOWNID);
3374 else
3375 our_id = ahd_inb(ahd, IOWNID);
3376
3377 saved_scsiid = ahd_inb(ahd, SAVED_SCSIID);
3378 ahd_compile_devinfo(devinfo,
3379 our_id,
3380 SCSIID_TARGET(ahd, saved_scsiid),
3381 ahd_inb(ahd, SAVED_LUN),
3382 SCSIID_CHANNEL(ahd, saved_scsiid),
3383 role);
3384 ahd_restore_modes(ahd, saved_modes);
3385 }
3386
3387 void
3388 ahd_print_devinfo(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
3389 {
3390 printf("%s:%c:%d:%d: (0x%x) ", ahd_name(ahd), 'A',
3391 devinfo->target, devinfo->lun, ahd_get_scbptr(ahd));
3392 }
3393
3394 struct ahd_phase_table_entry*
3395 ahd_lookup_phase_entry(int phase)
3396 {
3397 struct ahd_phase_table_entry *entry;
3398 struct ahd_phase_table_entry *last_entry;
3399
3400 /*
3401 * num_phases doesn't include the default entry which
3402 * will be returned if the phase doesn't match.
3403 */
3404 last_entry = &ahd_phase_table[num_phases];
3405 for (entry = ahd_phase_table; entry < last_entry; entry++) {
3406 if (phase == entry->phase)
3407 break;
3408 }
3409 return (entry);
3410 }
3411
3412 void
3413 ahd_compile_devinfo(struct ahd_devinfo *devinfo, u_int our_id, u_int target,
3414 u_int lun, char channel, role_t role)
3415 {
3416 devinfo->our_scsiid = our_id;
3417 devinfo->target = target;
3418 devinfo->lun = lun;
3419 devinfo->target_offset = target;
3420 devinfo->channel = channel;
3421 devinfo->role = role;
3422 if (channel == 'B')
3423 devinfo->target_offset += 8;
3424 devinfo->target_mask = (0x01 << devinfo->target_offset);
3425 }
3426
3427 static void
3428 ahd_scb_devinfo(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3429 struct scb *scb)
3430 {
3431 role_t role;
3432 int our_id;
3433
3434 our_id = SCSIID_OUR_ID(scb->hscb->scsiid);
3435 role = ROLE_INITIATOR;
3436 if ((scb->hscb->control & TARGET_SCB) != 0)
3437 role = ROLE_TARGET;
3438 ahd_compile_devinfo(devinfo, our_id, SCB_GET_TARGET(ahd, scb),
3439 SCB_GET_LUN(scb), SCB_GET_CHANNEL(ahd, scb), role);
3440 }
3441
3442
3443 /************************ Message Phase Processing ****************************/
3444 /*
3445 * When an initiator transaction with the MK_MESSAGE flag either reconnects
3446 * or enters the initial message out phase, we are interrupted. Fill our
3447 * outgoing message buffer with the appropriate message and begin handing
3448 * the message phase(s) manually.
3449 */
3450 static void
3451 ahd_setup_initiator_msgout(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3452 struct scb *scb)
3453 {
3454 /*
3455 * To facilitate adding multiple messages together,
3456 * each routine should increment the index and len
3457 * variables instead of setting them explicitly.
3458 */
3459 ahd->msgout_index = 0;
3460 ahd->msgout_len = 0;
3461
3462 if (ahd_currently_packetized(ahd))
3463 ahd->msg_flags |= MSG_FLAG_PACKETIZED;
3464
3465 if (ahd->send_msg_perror
3466 && ahd_inb(ahd, MSG_OUT) == HOST_MSG) {
3467 ahd->msgout_buf[ahd->msgout_index++] = ahd->send_msg_perror;
3468 ahd->msgout_len++;
3469 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
3470 #ifdef AHD_DEBUG
3471 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
3472 printf("Setting up for Parity Error delivery\n");
3473 #endif
3474 return;
3475 } else if (scb == NULL) {
3476 printf("%s: WARNING. No pending message for "
3477 "I_T msgin. Issuing NO-OP\n", ahd_name(ahd));
3478 ahd->msgout_buf[ahd->msgout_index++] = MSG_NOOP;
3479 ahd->msgout_len++;
3480 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
3481 return;
3482 }
3483
3484 if ((scb->flags & SCB_DEVICE_RESET) == 0
3485 && (scb->flags & SCB_PACKETIZED) == 0
3486 && ahd_inb(ahd, MSG_OUT) == MSG_IDENTIFYFLAG) {
3487 u_int identify_msg;
3488
3489 identify_msg = MSG_IDENTIFYFLAG | SCB_GET_LUN(scb);
3490 if ((scb->hscb->control & DISCENB) != 0)
3491 identify_msg |= MSG_IDENTIFY_DISCFLAG;
3492 ahd->msgout_buf[ahd->msgout_index++] = identify_msg;
3493 ahd->msgout_len++;
3494
3495 if ((scb->hscb->control & TAG_ENB) != 0) {
3496 ahd->msgout_buf[ahd->msgout_index++] =
3497 scb->hscb->control & (TAG_ENB|SCB_TAG_TYPE);
3498 ahd->msgout_buf[ahd->msgout_index++] = SCB_GET_TAG(scb);
3499 ahd->msgout_len += 2;
3500 }
3501 }
3502
3503 if (scb->flags & SCB_DEVICE_RESET) {
3504 ahd->msgout_buf[ahd->msgout_index++] = MSG_BUS_DEV_RESET;
3505 ahd->msgout_len++;
3506 ahd_print_path(ahd, scb);
3507 printf("Bus Device Reset Message Sent\n");
3508 /*
3509 * Clear our selection hardware in advance of
3510 * the busfree. We may have an entry in the waiting
3511 * Q for this target, and we don't want to go about
3512 * selecting while we handle the busfree and blow it
3513 * away.
3514 */
3515 ahd_outb(ahd, SCSISEQ0, 0);
3516 } else if ((scb->flags & SCB_ABORT) != 0) {
3517
3518 if ((scb->hscb->control & TAG_ENB) != 0) {
3519 ahd->msgout_buf[ahd->msgout_index++] = MSG_ABORT_TAG;
3520 } else {
3521 ahd->msgout_buf[ahd->msgout_index++] = MSG_ABORT;
3522 }
3523 ahd->msgout_len++;
3524 ahd_print_path(ahd, scb);
3525 printf("Abort%s Message Sent\n",
3526 (scb->hscb->control & TAG_ENB) != 0 ? " Tag" : "");
3527 /*
3528 * Clear our selection hardware in advance of
3529 * the busfree. We may have an entry in the waiting
3530 * Q for this target, and we don't want to go about
3531 * selecting while we handle the busfree and blow it
3532 * away.
3533 */
3534 ahd_outb(ahd, SCSISEQ0, 0);
3535 } else if ((scb->flags & (SCB_AUTO_NEGOTIATE|SCB_NEGOTIATE)) != 0) {
3536 ahd_build_transfer_msg(ahd, devinfo);
3537 /*
3538 * Clear our selection hardware in advance of potential
3539 * PPR IU status change busfree. We may have an entry in
3540 * the waiting Q for this target, and we don't want to go
3541 * about selecting while we handle the busfree and blow
3542 * it away.
3543 */
3544 ahd_outb(ahd, SCSISEQ0, 0);
3545 } else {
3546 printf("ahd_intr: AWAITING_MSG for an SCB that "
3547 "does not have a waiting message\n");
3548 printf("SCSIID = %x, target_mask = %x\n", scb->hscb->scsiid,
3549 devinfo->target_mask);
3550 panic("SCB = %d, SCB Control = %x:%x, MSG_OUT = %x "
3551 "SCB flags = %x", SCB_GET_TAG(scb), scb->hscb->control,
3552 ahd_inb_scbram(ahd, SCB_CONTROL), ahd_inb(ahd, MSG_OUT),
3553 scb->flags);
3554 }
3555
3556 /*
3557 * Clear the MK_MESSAGE flag from the SCB so we aren't
3558 * asked to send this message again.
3559 */
3560 ahd_outb(ahd, SCB_CONTROL,
3561 ahd_inb_scbram(ahd, SCB_CONTROL) & ~MK_MESSAGE);
3562 scb->hscb->control &= ~MK_MESSAGE;
3563 ahd->msgout_index = 0;
3564 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
3565 }
3566
3567 /*
3568 * Build an appropriate transfer negotiation message for the
3569 * currently active target.
3570 */
3571 static void
3572 ahd_build_transfer_msg(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
3573 {
3574 /*
3575 * We need to initiate transfer negotiations.
3576 * If our current and goal settings are identical,
3577 * we want to renegotiate due to a check condition.
3578 */
3579 struct ahd_initiator_tinfo *tinfo;
3580 struct ahd_tmode_tstate *tstate;
3581 int dowide;
3582 int dosync;
3583 int doppr;
3584 u_int period;
3585 u_int ppr_options;
3586 u_int offset;
3587
3588 tinfo = ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
3589 devinfo->target, &tstate);
3590 /*
3591 * Filter our period based on the current connection.
3592 * If we can't perform DT transfers on this segment (not in LVD
3593 * mode for instance), then our decision to issue a PPR message
3594 * may change.
3595 */
3596 period = tinfo->goal.period;
3597 offset = tinfo->goal.offset;
3598 ppr_options = tinfo->goal.ppr_options;
3599 /* Target initiated PPR is not allowed in the SCSI spec */
3600 if (devinfo->role == ROLE_TARGET)
3601 ppr_options = 0;
3602 ahd_devlimited_syncrate(ahd, tinfo, &period,
3603 &ppr_options, devinfo->role);
3604 dowide = tinfo->curr.width != tinfo->goal.width;
3605 dosync = tinfo->curr.offset != offset || tinfo->curr.period != period;
3606 /*
3607 * Only use PPR if we have options that need it, even if the device
3608 * claims to support it. There might be an expander in the way
3609 * that doesn't.
3610 */
3611 doppr = ppr_options != 0;
3612
3613 if (!dowide && !dosync && !doppr) {
3614 dowide = tinfo->goal.width != MSG_EXT_WDTR_BUS_8_BIT;
3615 dosync = tinfo->goal.offset != 0;
3616 }
3617
3618 if (!dowide && !dosync && !doppr) {
3619 /*
3620 * Force async with a WDTR message if we have a wide bus,
3621 * or just issue an SDTR with a 0 offset.
3622 */
3623 if ((ahd->features & AHD_WIDE) != 0)
3624 dowide = 1;
3625 else
3626 dosync = 1;
3627
3628 if (bootverbose) {
3629 ahd_print_devinfo(ahd, devinfo);
3630 printf("Ensuring async\n");
3631 }
3632 }
3633 /* Target initiated PPR is not allowed in the SCSI spec */
3634 if (devinfo->role == ROLE_TARGET)
3635 doppr = 0;
3636
3637 /*
3638 * Both the PPR message and SDTR message require the
3639 * goal syncrate to be limited to what the target device
3640 * is capable of handling (based on whether an LVD->SE
3641 * expander is on the bus), so combine these two cases.
3642 * Regardless, guarantee that if we are using WDTR and SDTR
3643 * messages that WDTR comes first.
3644 */
3645 if (doppr || (dosync && !dowide)) {
3646
3647 offset = tinfo->goal.offset;
3648 ahd_validate_offset(ahd, tinfo, period, &offset,
3649 doppr ? tinfo->goal.width
3650 : tinfo->curr.width,
3651 devinfo->role);
3652 if (doppr) {
3653 ahd_construct_ppr(ahd, devinfo, period, offset,
3654 tinfo->goal.width, ppr_options);
3655 } else {
3656 ahd_construct_sdtr(ahd, devinfo, period, offset);
3657 }
3658 } else {
3659 ahd_construct_wdtr(ahd, devinfo, tinfo->goal.width);
3660 }
3661 }
3662
3663 /*
3664 * Build a synchronous negotiation message in our message
3665 * buffer based on the input parameters.
3666 */
3667 static void
3668 ahd_construct_sdtr(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3669 u_int period, u_int offset)
3670 {
3671 if (offset == 0)
3672 period = AHD_ASYNC_XFER_PERIOD;
3673 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXTENDED;
3674 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_SDTR_LEN;
3675 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_SDTR;
3676 ahd->msgout_buf[ahd->msgout_index++] = period;
3677 ahd->msgout_buf[ahd->msgout_index++] = offset;
3678 ahd->msgout_len += 5;
3679 if (bootverbose) {
3680 printf("(%s:%c:%d:%d): Sending SDTR period %x, offset %x\n",
3681 ahd_name(ahd), devinfo->channel, devinfo->target,
3682 devinfo->lun, period, offset);
3683 }
3684 }
3685
3686 /*
3687 * Build a wide negotiation message in our message
3688 * buffer based on the input parameters.
3689 */
3690 static void
3691 ahd_construct_wdtr(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3692 u_int bus_width)
3693 {
3694 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXTENDED;
3695 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_WDTR_LEN;
3696 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_WDTR;
3697 ahd->msgout_buf[ahd->msgout_index++] = bus_width;
3698 ahd->msgout_len += 4;
3699 if (bootverbose) {
3700 printf("(%s:%c:%d:%d): Sending WDTR %x\n",
3701 ahd_name(ahd), devinfo->channel, devinfo->target,
3702 devinfo->lun, bus_width);
3703 }
3704 }
3705
3706 /*
3707 * Build a parallel protocol request message in our message
3708 * buffer based on the input parameters.
3709 */
3710 static void
3711 ahd_construct_ppr(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
3712 u_int period, u_int offset, u_int bus_width,
3713 u_int ppr_options)
3714 {
3715 /*
3716 * Always request precompensation from
3717 * the other target if we are running
3718 * at paced syncrates.
3719 */
3720 if (period <= AHD_SYNCRATE_PACED)
3721 ppr_options |= MSG_EXT_PPR_PCOMP_EN;
3722 if (offset == 0)
3723 period = AHD_ASYNC_XFER_PERIOD;
3724 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXTENDED;
3725 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_PPR_LEN;
3726 ahd->msgout_buf[ahd->msgout_index++] = MSG_EXT_PPR;
3727 ahd->msgout_buf[ahd->msgout_index++] = period;
3728 ahd->msgout_buf[ahd->msgout_index++] = 0;
3729 ahd->msgout_buf[ahd->msgout_index++] = offset;
3730 ahd->msgout_buf[ahd->msgout_index++] = bus_width;
3731 ahd->msgout_buf[ahd->msgout_index++] = ppr_options;
3732 ahd->msgout_len += 8;
3733 if (bootverbose) {
3734 printf("(%s:%c:%d:%d): Sending PPR bus_width %x, period 0x%x, "
3735 "offset 0x%x, ppr_options 0x%x\n", ahd_name(ahd),
3736 devinfo->channel, devinfo->target, devinfo->lun,
3737 bus_width, period, offset, ppr_options);
3738 }
3739 }
3740
3741 /*
3742 * Clear any active message state.
3743 */
3744 static void
3745 ahd_clear_msg_state(struct ahd_softc *ahd)
3746 {
3747 ahd_mode_state saved_modes;
3748
3749 saved_modes = ahd_save_modes(ahd);
3750 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
3751 ahd->send_msg_perror = 0;
3752 ahd->msg_flags = MSG_FLAG_NONE;
3753 ahd->msgout_len = 0;
3754 ahd->msgin_index = 0;
3755 ahd->msg_type = MSG_TYPE_NONE;
3756 if ((ahd_inb(ahd, SCSISIGO) & ATNO) != 0) {
3757 /*
3758 * The target didn't care to respond to our
3759 * message request, so clear ATN.
3760 */
3761 ahd_outb(ahd, CLRSINT1, CLRATNO);
3762 }
3763 ahd_outb(ahd, MSG_OUT, MSG_NOOP);
3764 ahd_outb(ahd, SEQ_FLAGS2,
3765 ahd_inb(ahd, SEQ_FLAGS2) & ~TARGET_MSG_PENDING);
3766 ahd_restore_modes(ahd, saved_modes);
3767 }
3768
3769 /*
3770 * Manual message loop handler.
3771 */
3772 static void
3773 ahd_handle_message_phase(struct ahd_softc *ahd)
3774 {
3775 struct ahd_devinfo devinfo;
3776 u_int bus_phase;
3777 int end_session;
3778
3779 ahd_fetch_devinfo(ahd, &devinfo);
3780 end_session = FALSE;
3781 bus_phase = ahd_inb(ahd, LASTPHASE);
3782
3783 if ((ahd_inb(ahd, LQISTAT2) & LQIPHASE_OUTPKT) != 0) {
3784 printf("LQIRETRY for LQIPHASE_OUTPKT\n");
3785 ahd_outb(ahd, LQCTL2, LQIRETRY);
3786 }
3787 reswitch:
3788 switch (ahd->msg_type) {
3789 case MSG_TYPE_INITIATOR_MSGOUT:
3790 {
3791 int lastbyte;
3792 int phasemis;
3793 int msgdone;
3794
3795 if (ahd->msgout_len == 0 && ahd->send_msg_perror == 0)
3796 panic("HOST_MSG_LOOP interrupt with no active message");
3797
3798 #ifdef AHD_DEBUG
3799 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3800 ahd_print_devinfo(ahd, &devinfo);
3801 printf("INITIATOR_MSG_OUT");
3802 }
3803 #endif
3804 phasemis = bus_phase != P_MESGOUT;
3805 if (phasemis) {
3806 #ifdef AHD_DEBUG
3807 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3808 printf(" PHASEMIS %s\n",
3809 ahd_lookup_phase_entry(bus_phase)
3810 ->phasemsg);
3811 }
3812 #endif
3813 if (bus_phase == P_MESGIN) {
3814 /*
3815 * Change gears and see if
3816 * this messages is of interest to
3817 * us or should be passed back to
3818 * the sequencer.
3819 */
3820 ahd_outb(ahd, CLRSINT1, CLRATNO);
3821 ahd->send_msg_perror = 0;
3822 ahd->msg_type = MSG_TYPE_INITIATOR_MSGIN;
3823 ahd->msgin_index = 0;
3824 goto reswitch;
3825 }
3826 end_session = TRUE;
3827 break;
3828 }
3829
3830 if (ahd->send_msg_perror) {
3831 ahd_outb(ahd, CLRSINT1, CLRATNO);
3832 ahd_outb(ahd, CLRSINT1, CLRREQINIT);
3833 #ifdef AHD_DEBUG
3834 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
3835 printf(" byte 0x%x\n", ahd->send_msg_perror);
3836 #endif
3837 /*
3838 * If we are notifying the target of a CRC error
3839 * during packetized operations, the target is
3840 * within its rights to acknowledge our message
3841 * with a busfree.
3842 */
3843 if ((ahd->msg_flags & MSG_FLAG_PACKETIZED) != 0
3844 && ahd->send_msg_perror == MSG_INITIATOR_DET_ERR)
3845 ahd->msg_flags |= MSG_FLAG_EXPECT_IDE_BUSFREE;
3846
3847 ahd_outb(ahd, RETURN_2, ahd->send_msg_perror);
3848 ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_WRITE);
3849 break;
3850 }
3851
3852 msgdone = ahd->msgout_index == ahd->msgout_len;
3853 if (msgdone) {
3854 /*
3855 * The target has requested a retry.
3856 * Re-assert ATN, reset our message index to
3857 * 0, and try again.
3858 */
3859 ahd->msgout_index = 0;
3860 ahd_assert_atn(ahd);
3861 }
3862
3863 lastbyte = ahd->msgout_index == (ahd->msgout_len - 1);
3864 if (lastbyte) {
3865 /* Last byte is signified by dropping ATN */
3866 ahd_outb(ahd, CLRSINT1, CLRATNO);
3867 }
3868
3869 /*
3870 * Clear our interrupt status and present
3871 * the next byte on the bus.
3872 */
3873 ahd_outb(ahd, CLRSINT1, CLRREQINIT);
3874 #ifdef AHD_DEBUG
3875 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
3876 printf(" byte 0x%x\n",
3877 ahd->msgout_buf[ahd->msgout_index]);
3878 #endif
3879 ahd_outb(ahd, RETURN_2, ahd->msgout_buf[ahd->msgout_index++]);
3880 ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_WRITE);
3881 break;
3882 }
3883 case MSG_TYPE_INITIATOR_MSGIN:
3884 {
3885 int phasemis;
3886 int message_done;
3887
3888 #ifdef AHD_DEBUG
3889 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3890 ahd_print_devinfo(ahd, &devinfo);
3891 printf("INITIATOR_MSG_IN");
3892 }
3893 #endif
3894 phasemis = bus_phase != P_MESGIN;
3895 if (phasemis) {
3896 #ifdef AHD_DEBUG
3897 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3898 printf(" PHASEMIS %s\n",
3899 ahd_lookup_phase_entry(bus_phase)
3900 ->phasemsg);
3901 }
3902 #endif
3903 ahd->msgin_index = 0;
3904 if (bus_phase == P_MESGOUT
3905 && (ahd->send_msg_perror != 0
3906 || (ahd->msgout_len != 0
3907 && ahd->msgout_index == 0))) {
3908 ahd->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
3909 goto reswitch;
3910 }
3911 end_session = TRUE;
3912 break;
3913 }
3914
3915 /* Pull the byte in without acking it */
3916 ahd->msgin_buf[ahd->msgin_index] = ahd_inb(ahd, SCSIBUS);
3917 #ifdef AHD_DEBUG
3918 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
3919 printf(" byte 0x%x\n",
3920 ahd->msgin_buf[ahd->msgin_index]);
3921 #endif
3922
3923 message_done = ahd_parse_msg(ahd, &devinfo);
3924
3925 if (message_done) {
3926 /*
3927 * Clear our incoming message buffer in case there
3928 * is another message following this one.
3929 */
3930 ahd->msgin_index = 0;
3931
3932 /*
3933 * If this message illicited a response,
3934 * assert ATN so the target takes us to the
3935 * message out phase.
3936 */
3937 if (ahd->msgout_len != 0) {
3938 #ifdef AHD_DEBUG
3939 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0) {
3940 ahd_print_devinfo(ahd, &devinfo);
3941 printf("Asserting ATN for response\n");
3942 }
3943 #endif
3944 ahd_assert_atn(ahd);
3945 }
3946 } else
3947 ahd->msgin_index++;
3948
3949 if (message_done == MSGLOOP_TERMINATED) {
3950 end_session = TRUE;
3951 } else {
3952 /* Ack the byte */
3953 ahd_outb(ahd, CLRSINT1, CLRREQINIT);
3954 ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_READ);
3955 }
3956 break;
3957 }
3958 case MSG_TYPE_TARGET_MSGIN:
3959 {
3960 int msgdone;
3961 int msgout_request;
3962
3963 /*
3964 * By default, the message loop will continue.
3965 */
3966 ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_TARG);
3967
3968 if (ahd->msgout_len == 0)
3969 panic("Target MSGIN with no active message");
3970
3971 /*
3972 * If we interrupted a mesgout session, the initiator
3973 * will not know this until our first REQ. So, we
3974 * only honor mesgout requests after we've sent our
3975 * first byte.
3976 */
3977 if ((ahd_inb(ahd, SCSISIGI) & ATNI) != 0
3978 && ahd->msgout_index > 0)
3979 msgout_request = TRUE;
3980 else
3981 msgout_request = FALSE;
3982
3983 if (msgout_request) {
3984
3985 /*
3986 * Change gears and see if
3987 * this messages is of interest to
3988 * us or should be passed back to
3989 * the sequencer.
3990 */
3991 ahd->msg_type = MSG_TYPE_TARGET_MSGOUT;
3992 ahd_outb(ahd, SCSISIGO, P_MESGOUT | BSYO);
3993 ahd->msgin_index = 0;
3994 /* Dummy read to REQ for first byte */
3995 ahd_inb(ahd, SCSIDAT);
3996 ahd_outb(ahd, SXFRCTL0,
3997 ahd_inb(ahd, SXFRCTL0) | SPIOEN);
3998 break;
3999 }
4000
4001 msgdone = ahd->msgout_index == ahd->msgout_len;
4002 if (msgdone) {
4003 ahd_outb(ahd, SXFRCTL0,
4004 ahd_inb(ahd, SXFRCTL0) & ~SPIOEN);
4005 end_session = TRUE;
4006 break;
4007 }
4008
4009 /*
4010 * Present the next byte on the bus.
4011 */
4012 ahd_outb(ahd, SXFRCTL0, ahd_inb(ahd, SXFRCTL0) | SPIOEN);
4013 ahd_outb(ahd, SCSIDAT, ahd->msgout_buf[ahd->msgout_index++]);
4014 break;
4015 }
4016 case MSG_TYPE_TARGET_MSGOUT:
4017 {
4018 int lastbyte;
4019 int msgdone;
4020
4021 /*
4022 * By default, the message loop will continue.
4023 */
4024 ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_TARG);
4025
4026 /*
4027 * The initiator signals that this is
4028 * the last byte by dropping ATN.
4029 */
4030 lastbyte = (ahd_inb(ahd, SCSISIGI) & ATNI) == 0;
4031
4032 /*
4033 * Read the latched byte, but turn off SPIOEN first
4034 * so that we don't inadvertently cause a REQ for the
4035 * next byte.
4036 */
4037 ahd_outb(ahd, SXFRCTL0, ahd_inb(ahd, SXFRCTL0) & ~SPIOEN);
4038 ahd->msgin_buf[ahd->msgin_index] = ahd_inb(ahd, SCSIDAT);
4039 msgdone = ahd_parse_msg(ahd, &devinfo);
4040 if (msgdone == MSGLOOP_TERMINATED) {
4041 /*
4042 * The message is *really* done in that it caused
4043 * us to go to bus free. The sequencer has already
4044 * been reset at this point, so pull the ejection
4045 * handle.
4046 */
4047 return;
4048 }
4049
4050 ahd->msgin_index++;
4051
4052 /*
4053 * XXX Read spec about initiator dropping ATN too soon
4054 * and use msgdone to detect it.
4055 */
4056 if (msgdone == MSGLOOP_MSGCOMPLETE) {
4057 ahd->msgin_index = 0;
4058
4059 /*
4060 * If this message illicited a response, transition
4061 * to the Message in phase and send it.
4062 */
4063 if (ahd->msgout_len != 0) {
4064 ahd_outb(ahd, SCSISIGO, P_MESGIN | BSYO);
4065 ahd_outb(ahd, SXFRCTL0,
4066 ahd_inb(ahd, SXFRCTL0) | SPIOEN);
4067 ahd->msg_type = MSG_TYPE_TARGET_MSGIN;
4068 ahd->msgin_index = 0;
4069 break;
4070 }
4071 }
4072
4073 if (lastbyte)
4074 end_session = TRUE;
4075 else {
4076 /* Ask for the next byte. */
4077 ahd_outb(ahd, SXFRCTL0,
4078 ahd_inb(ahd, SXFRCTL0) | SPIOEN);
4079 }
4080
4081 break;
4082 }
4083 default:
4084 panic("Unknown REQINIT message type");
4085 }
4086
4087 if (end_session) {
4088 if ((ahd->msg_flags & MSG_FLAG_PACKETIZED) != 0) {
4089 printf("%s: Returning to Idle Loop\n",
4090 ahd_name(ahd));
4091 ahd_clear_msg_state(ahd);
4092
4093 /*
4094 * Perform the equivalent of a clear_target_state.
4095 */
4096 ahd_outb(ahd, LASTPHASE, P_BUSFREE);
4097 ahd_outb(ahd, SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT);
4098 ahd_outb(ahd, SEQCTL0, FASTMODE|SEQRESET);
4099 } else {
4100 ahd_clear_msg_state(ahd);
4101 ahd_outb(ahd, RETURN_1, EXIT_MSG_LOOP);
4102 }
4103 }
4104 }
4105
4106 /*
4107 * See if we sent a particular extended message to the target.
4108 * If "full" is true, return true only if the target saw the full
4109 * message. If "full" is false, return true if the target saw at
4110 * least the first byte of the message.
4111 */
4112 static int
4113 ahd_sent_msg(struct ahd_softc *ahd, ahd_msgtype type, u_int msgval, int full)
4114 {
4115 int found;
4116 u_int index;
4117
4118 found = FALSE;
4119 index = 0;
4120
4121 while (index < ahd->msgout_len) {
4122 if (ahd->msgout_buf[index] == MSG_EXTENDED) {
4123 u_int end_index;
4124
4125 end_index = index + 1 + ahd->msgout_buf[index + 1];
4126 if (ahd->msgout_buf[index+2] == msgval
4127 && type == AHDMSG_EXT) {
4128
4129 if (full) {
4130 if (ahd->msgout_index > end_index)
4131 found = TRUE;
4132 } else if (ahd->msgout_index > index)
4133 found = TRUE;
4134 }
4135 index = end_index;
4136 } else if (ahd->msgout_buf[index] >= MSG_SIMPLE_TASK
4137 && ahd->msgout_buf[index] <= MSG_IGN_WIDE_RESIDUE) {
4138
4139 /* Skip tag type and tag id or residue param*/
4140 index += 2;
4141 } else {
4142 /* Single byte message */
4143 if (type == AHDMSG_1B
4144 && ahd->msgout_index > index
4145 && (ahd->msgout_buf[index] == msgval
4146 || ((ahd->msgout_buf[index] & MSG_IDENTIFYFLAG) != 0
4147 && msgval == MSG_IDENTIFYFLAG)))
4148 found = TRUE;
4149 index++;
4150 }
4151
4152 if (found)
4153 break;
4154 }
4155 return (found);
4156 }
4157
4158 /*
4159 * Wait for a complete incoming message, parse it, and respond accordingly.
4160 */
4161 static int
4162 ahd_parse_msg(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
4163 {
4164 struct ahd_initiator_tinfo *tinfo;
4165 struct ahd_tmode_tstate *tstate;
4166 int reject;
4167 int done;
4168 int response;
4169
4170 done = MSGLOOP_IN_PROG;
4171 response = FALSE;
4172 reject = FALSE;
4173 tinfo = ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
4174 devinfo->target, &tstate);
4175
4176 /*
4177 * Parse as much of the message as is available,
4178 * rejecting it if we don't support it. When
4179 * the entire message is available and has been
4180 * handled, return MSGLOOP_MSGCOMPLETE, indicating
4181 * that we have parsed an entire message.
4182 *
4183 * In the case of extended messages, we accept the length
4184 * byte outright and perform more checking once we know the
4185 * extended message type.
4186 */
4187 switch (ahd->msgin_buf[0]) {
4188 case MSG_DISCONNECT:
4189 case MSG_SAVEDATAPOINTER:
4190 case MSG_CMDCOMPLETE:
4191 case MSG_RESTOREPOINTERS:
4192 case MSG_IGN_WIDE_RESIDUE:
4193 /*
4194 * End our message loop as these are messages
4195 * the sequencer handles on its own.
4196 */
4197 done = MSGLOOP_TERMINATED;
4198 break;
4199 case MSG_MESSAGE_REJECT:
4200 response = ahd_handle_msg_reject(ahd, devinfo);
4201 /* FALLTHROUGH */
4202 case MSG_NOOP:
4203 done = MSGLOOP_MSGCOMPLETE;
4204 break;
4205 case MSG_EXTENDED:
4206 {
4207 /* Wait for enough of the message to begin validation */
4208 if (ahd->msgin_index < 2)
4209 break;
4210 switch (ahd->msgin_buf[2]) {
4211 case MSG_EXT_SDTR:
4212 {
4213 u_int period;
4214 u_int ppr_options;
4215 u_int offset;
4216 u_int saved_offset;
4217
4218 if (ahd->msgin_buf[1] != MSG_EXT_SDTR_LEN) {
4219 reject = TRUE;
4220 break;
4221 }
4222
4223 /*
4224 * Wait until we have both args before validating
4225 * and acting on this message.
4226 *
4227 * Add one to MSG_EXT_SDTR_LEN to account for
4228 * the extended message preamble.
4229 */
4230 if (ahd->msgin_index < (MSG_EXT_SDTR_LEN + 1))
4231 break;
4232
4233 period = ahd->msgin_buf[3];
4234 ppr_options = 0;
4235 saved_offset = offset = ahd->msgin_buf[4];
4236 ahd_devlimited_syncrate(ahd, tinfo, &period,
4237 &ppr_options, devinfo->role);
4238 ahd_validate_offset(ahd, tinfo, period, &offset,
4239 tinfo->curr.width, devinfo->role);
4240 if (bootverbose) {
4241 printf("(%s:%c:%d:%d): Received "
4242 "SDTR period %x, offset %x\n\t"
4243 "Filtered to period %x, offset %x\n",
4244 ahd_name(ahd), devinfo->channel,
4245 devinfo->target, devinfo->lun,
4246 ahd->msgin_buf[3], saved_offset,
4247 period, offset);
4248 }
4249 ahd_set_syncrate(ahd, devinfo, period,
4250 offset, ppr_options,
4251 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4252 /*paused*/TRUE);
4253
4254 /*
4255 * See if we initiated Sync Negotiation
4256 * and didn't have to fall down to async
4257 * transfers.
4258 */
4259 if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, TRUE)) {
4260 /* We started it */
4261 if (saved_offset != offset) {
4262 /* Went too low - force async */
4263 reject = TRUE;
4264 }
4265 } else {
4266 /*
4267 * Send our own SDTR in reply
4268 */
4269 if (bootverbose
4270 && devinfo->role == ROLE_INITIATOR) {
4271 printf("(%s:%c:%d:%d): Target "
4272 "Initiated SDTR\n",
4273 ahd_name(ahd), devinfo->channel,
4274 devinfo->target, devinfo->lun);
4275 }
4276 ahd->msgout_index = 0;
4277 ahd->msgout_len = 0;
4278 ahd_construct_sdtr(ahd, devinfo,
4279 period, offset);
4280 ahd->msgout_index = 0;
4281 response = TRUE;
4282 }
4283 done = MSGLOOP_MSGCOMPLETE;
4284 break;
4285 }
4286 case MSG_EXT_WDTR:
4287 {
4288 u_int bus_width;
4289 u_int saved_width;
4290 u_int sending_reply;
4291
4292 sending_reply = FALSE;
4293 if (ahd->msgin_buf[1] != MSG_EXT_WDTR_LEN) {
4294 reject = TRUE;
4295 break;
4296 }
4297
4298 /*
4299 * Wait until we have our arg before validating
4300 * and acting on this message.
4301 *
4302 * Add one to MSG_EXT_WDTR_LEN to account for
4303 * the extended message preamble.
4304 */
4305 if (ahd->msgin_index < (MSG_EXT_WDTR_LEN + 1))
4306 break;
4307
4308 bus_width = ahd->msgin_buf[3];
4309 saved_width = bus_width;
4310 ahd_validate_width(ahd, tinfo, &bus_width,
4311 devinfo->role);
4312 if (bootverbose) {
4313 printf("(%s:%c:%d:%d): Received WDTR "
4314 "%x filtered to %x\n",
4315 ahd_name(ahd), devinfo->channel,
4316 devinfo->target, devinfo->lun,
4317 saved_width, bus_width);
4318 }
4319
4320 if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, TRUE)) {
4321 /*
4322 * Don't send a WDTR back to the
4323 * target, since we asked first.
4324 * If the width went higher than our
4325 * request, reject it.
4326 */
4327 if (saved_width > bus_width) {
4328 reject = TRUE;
4329 printf("(%s:%c:%d:%d): requested %dBit "
4330 "transfers. Rejecting...\n",
4331 ahd_name(ahd), devinfo->channel,
4332 devinfo->target, devinfo->lun,
4333 8 * (0x01 << bus_width));
4334 bus_width = 0;
4335 }
4336 } else {
4337 /*
4338 * Send our own WDTR in reply
4339 */
4340 if (bootverbose
4341 && devinfo->role == ROLE_INITIATOR) {
4342 printf("(%s:%c:%d:%d): Target "
4343 "Initiated WDTR\n",
4344 ahd_name(ahd), devinfo->channel,
4345 devinfo->target, devinfo->lun);
4346 }
4347 ahd->msgout_index = 0;
4348 ahd->msgout_len = 0;
4349 ahd_construct_wdtr(ahd, devinfo, bus_width);
4350 ahd->msgout_index = 0;
4351 response = TRUE;
4352 sending_reply = TRUE;
4353 }
4354 /*
4355 * After a wide message, we are async, but
4356 * some devices don't seem to honor this portion
4357 * of the spec. Force a renegotiation of the
4358 * sync component of our transfer agreement even
4359 * if our goal is async. By updating our width
4360 * after forcing the negotiation, we avoid
4361 * renegotiating for width.
4362 */
4363 ahd_update_neg_request(ahd, devinfo, tstate,
4364 tinfo, AHD_NEG_ALWAYS);
4365 ahd_set_width(ahd, devinfo, bus_width,
4366 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4367 /*paused*/TRUE);
4368 if (sending_reply == FALSE && reject == FALSE) {
4369
4370 /*
4371 * We will always have an SDTR to send.
4372 */
4373 ahd->msgout_index = 0;
4374 ahd->msgout_len = 0;
4375 ahd_build_transfer_msg(ahd, devinfo);
4376 ahd->msgout_index = 0;
4377 response = TRUE;
4378 }
4379 done = MSGLOOP_MSGCOMPLETE;
4380 break;
4381 }
4382 case MSG_EXT_PPR:
4383 {
4384 u_int period;
4385 u_int offset;
4386 u_int bus_width;
4387 u_int ppr_options;
4388 u_int saved_width;
4389 u_int saved_offset;
4390 u_int saved_ppr_options;
4391
4392 if (ahd->msgin_buf[1] != MSG_EXT_PPR_LEN) {
4393 reject = TRUE;
4394 break;
4395 }
4396
4397 /*
4398 * Wait until we have all args before validating
4399 * and acting on this message.
4400 *
4401 * Add one to MSG_EXT_PPR_LEN to account for
4402 * the extended message preamble.
4403 */
4404 if (ahd->msgin_index < (MSG_EXT_PPR_LEN + 1))
4405 break;
4406
4407 period = ahd->msgin_buf[3];
4408 offset = ahd->msgin_buf[5];
4409 bus_width = ahd->msgin_buf[6];
4410 saved_width = bus_width;
4411 ppr_options = ahd->msgin_buf[7];
4412 /*
4413 * According to the spec, a DT only
4414 * period factor with no DT option
4415 * set implies async.
4416 */
4417 if ((ppr_options & MSG_EXT_PPR_DT_REQ) == 0
4418 && period <= 9)
4419 offset = 0;
4420 saved_ppr_options = ppr_options;
4421 saved_offset = offset;
4422
4423 /*
4424 * Transfer options are only available if we
4425 * are negotiating wide.
4426 */
4427 if (bus_width == 0)
4428 ppr_options &= MSG_EXT_PPR_QAS_REQ;
4429
4430 ahd_validate_width(ahd, tinfo, &bus_width,
4431 devinfo->role);
4432 ahd_devlimited_syncrate(ahd, tinfo, &period,
4433 &ppr_options, devinfo->role);
4434 ahd_validate_offset(ahd, tinfo, period, &offset,
4435 bus_width, devinfo->role);
4436
4437 if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_PPR, TRUE)) {
4438 /*
4439 * If we are unable to do any of the
4440 * requested options (we went too low),
4441 * then we'll have to reject the message.
4442 */
4443 if (saved_width > bus_width
4444 || saved_offset != offset
4445 || saved_ppr_options != ppr_options) {
4446 reject = TRUE;
4447 period = 0;
4448 offset = 0;
4449 bus_width = 0;
4450 ppr_options = 0;
4451 }
4452 } else {
4453 if (devinfo->role != ROLE_TARGET)
4454 printf("(%s:%c:%d:%d): Target "
4455 "Initiated PPR\n",
4456 ahd_name(ahd), devinfo->channel,
4457 devinfo->target, devinfo->lun);
4458 else
4459 printf("(%s:%c:%d:%d): Initiator "
4460 "Initiated PPR\n",
4461 ahd_name(ahd), devinfo->channel,
4462 devinfo->target, devinfo->lun);
4463 ahd->msgout_index = 0;
4464 ahd->msgout_len = 0;
4465 ahd_construct_ppr(ahd, devinfo, period, offset,
4466 bus_width, ppr_options);
4467 ahd->msgout_index = 0;
4468 response = TRUE;
4469 }
4470 if (bootverbose) {
4471 printf("(%s:%c:%d:%d): Received PPR width %x, "
4472 "period %x, offset %x,options %x\n"
4473 "\tFiltered to width %x, period %x, "
4474 "offset %x, options %x\n",
4475 ahd_name(ahd), devinfo->channel,
4476 devinfo->target, devinfo->lun,
4477 saved_width, ahd->msgin_buf[3],
4478 saved_offset, saved_ppr_options,
4479 bus_width, period, offset, ppr_options);
4480 }
4481 ahd_set_width(ahd, devinfo, bus_width,
4482 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4483 /*paused*/TRUE);
4484 ahd_set_syncrate(ahd, devinfo, period,
4485 offset, ppr_options,
4486 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4487 /*paused*/TRUE);
4488
4489 done = MSGLOOP_MSGCOMPLETE;
4490 break;
4491 }
4492 default:
4493 /* Unknown extended message. Reject it. */
4494 reject = TRUE;
4495 break;
4496 }
4497 break;
4498 }
4499 #ifdef AHD_TARGET_MODE
4500 case MSG_BUS_DEV_RESET:
4501 ahd_handle_devreset(ahd, devinfo, CAM_LUN_WILDCARD,
4502 CAM_BDR_SENT,
4503 "Bus Device Reset Received",
4504 /*verbose_level*/0);
4505 ahd_restart(ahd);
4506 done = MSGLOOP_TERMINATED;
4507 break;
4508 case MSG_ABORT_TAG:
4509 case MSG_ABORT:
4510 case MSG_CLEAR_QUEUE:
4511 {
4512 int tag;
4513
4514 /* Target mode messages */
4515 if (devinfo->role != ROLE_TARGET) {
4516 reject = TRUE;
4517 break;
4518 }
4519 tag = SCB_LIST_NULL;
4520 if (ahd->msgin_buf[0] == MSG_ABORT_TAG)
4521 tag = ahd_inb(ahd, INITIATOR_TAG);
4522 ahd_abort_scbs(ahd, devinfo->target, devinfo->channel,
4523 devinfo->lun, tag, ROLE_TARGET,
4524 CAM_REQ_ABORTED);
4525
4526 tstate = ahd->enabled_targets[devinfo->our_scsiid];
4527 if (tstate != NULL) {
4528 struct ahd_tmode_lstate* lstate;
4529
4530 lstate = tstate->enabled_luns[devinfo->lun];
4531 if (lstate != NULL) {
4532 ahd_queue_lstate_event(ahd, lstate,
4533 devinfo->our_scsiid,
4534 ahd->msgin_buf[0],
4535 /*arg*/tag);
4536 ahd_send_lstate_events(ahd, lstate);
4537 }
4538 }
4539 ahd_restart(ahd);
4540 done = MSGLOOP_TERMINATED;
4541 break;
4542 }
4543 #endif
4544 case MSG_QAS_REQUEST:
4545 #ifdef AHD_DEBUG
4546 if ((ahd_debug & AHD_SHOW_MESSAGES) != 0)
4547 printf("%s: QAS request. SCSISIGI == 0x%x\n",
4548 ahd_name(ahd), ahd_inb(ahd, SCSISIGI));
4549 #endif
4550 ahd->msg_flags |= MSG_FLAG_EXPECT_QASREJ_BUSFREE;
4551 /* FALLTHROUGH */
4552 case MSG_TERM_IO_PROC:
4553 default:
4554 reject = TRUE;
4555 break;
4556 }
4557
4558 if (reject) {
4559 /*
4560 * Setup to reject the message.
4561 */
4562 ahd->msgout_index = 0;
4563 ahd->msgout_len = 1;
4564 ahd->msgout_buf[0] = MSG_MESSAGE_REJECT;
4565 done = MSGLOOP_MSGCOMPLETE;
4566 response = TRUE;
4567 }
4568
4569 if (done != MSGLOOP_IN_PROG && !response)
4570 /* Clear the outgoing message buffer */
4571 ahd->msgout_len = 0;
4572
4573 return (done);
4574 }
4575
4576 /*
4577 * Process a message reject message.
4578 */
4579 static int
4580 ahd_handle_msg_reject(struct ahd_softc *ahd, struct ahd_devinfo *devinfo)
4581 {
4582 /*
4583 * What we care about here is if we had an
4584 * outstanding SDTR or WDTR message for this
4585 * target. If we did, this is a signal that
4586 * the target is refusing negotiation.
4587 */
4588 struct scb *scb;
4589 struct ahd_initiator_tinfo *tinfo;
4590 struct ahd_tmode_tstate *tstate;
4591 u_int scb_index;
4592 u_int last_msg;
4593 int response = 0;
4594
4595 scb_index = ahd_get_scbptr(ahd);
4596 scb = ahd_lookup_scb(ahd, scb_index);
4597 tinfo = ahd_fetch_transinfo(ahd, devinfo->channel,
4598 devinfo->our_scsiid,
4599 devinfo->target, &tstate);
4600 /* Might be necessary */
4601 last_msg = ahd_inb(ahd, LAST_MSG);
4602
4603 if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_PPR, /*full*/FALSE)) {
4604 if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_PPR, /*full*/TRUE)
4605 && tinfo->goal.period <= AHD_SYNCRATE_PACED) {
4606 /*
4607 * Target may not like our SPI-4 PPR Options.
4608 * Attempt to negotiate 80MHz which will turn
4609 * off these options.
4610 */
4611 if (bootverbose) {
4612 printf("(%s:%c:%d:%d): PPR Rejected. "
4613 "Trying simple U160 PPR\n",
4614 ahd_name(ahd), devinfo->channel,
4615 devinfo->target, devinfo->lun);
4616 }
4617 tinfo->goal.period = AHD_SYNCRATE_DT;
4618 tinfo->goal.ppr_options &= MSG_EXT_PPR_IU_REQ
4619 | MSG_EXT_PPR_QAS_REQ
4620 | MSG_EXT_PPR_DT_REQ;
4621 } else {
4622 /*
4623 * Target does not support the PPR message.
4624 * Attempt to negotiate SPI-2 style.
4625 */
4626 if (bootverbose) {
4627 printf("(%s:%c:%d:%d): PPR Rejected. "
4628 "Trying WDTR/SDTR\n",
4629 ahd_name(ahd), devinfo->channel,
4630 devinfo->target, devinfo->lun);
4631 }
4632 tinfo->goal.ppr_options = 0;
4633 tinfo->curr.transport_version = 2;
4634 tinfo->goal.transport_version = 2;
4635 }
4636 ahd->msgout_index = 0;
4637 ahd->msgout_len = 0;
4638 ahd_build_transfer_msg(ahd, devinfo);
4639 ahd->msgout_index = 0;
4640 response = 1;
4641 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, /*full*/FALSE)) {
4642
4643 /* note 8bit xfers */
4644 printf("(%s:%c:%d:%d): refuses WIDE negotiation. Using "
4645 "8bit transfers\n", ahd_name(ahd),
4646 devinfo->channel, devinfo->target, devinfo->lun);
4647 ahd_set_width(ahd, devinfo, MSG_EXT_WDTR_BUS_8_BIT,
4648 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4649 /*paused*/TRUE);
4650 /*
4651 * No need to clear the sync rate. If the target
4652 * did not accept the command, our syncrate is
4653 * unaffected. If the target started the negotiation,
4654 * but rejected our response, we already cleared the
4655 * sync rate before sending our WDTR.
4656 */
4657 if (tinfo->goal.offset != tinfo->curr.offset) {
4658
4659 /* Start the sync negotiation */
4660 ahd->msgout_index = 0;
4661 ahd->msgout_len = 0;
4662 ahd_build_transfer_msg(ahd, devinfo);
4663 ahd->msgout_index = 0;
4664 response = 1;
4665 }
4666 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, /*full*/FALSE)) {
4667 /* note asynch xfers and clear flag */
4668 ahd_set_syncrate(ahd, devinfo, /*period*/0,
4669 /*offset*/0, /*ppr_options*/0,
4670 AHD_TRANS_ACTIVE|AHD_TRANS_GOAL,
4671 /*paused*/TRUE);
4672 printf("(%s:%c:%d:%d): refuses synchronous negotiation. "
4673 "Using asynchronous transfers\n",
4674 ahd_name(ahd), devinfo->channel,
4675 devinfo->target, devinfo->lun);
4676 } else if ((scb->hscb->control & MSG_SIMPLE_TASK) != 0) {
4677 int tag_type;
4678 int mask;
4679
4680 tag_type = (scb->hscb->control & MSG_SIMPLE_TASK);
4681
4682 if (tag_type == MSG_SIMPLE_TASK) {
4683 printf("(%s:%c:%d:%d): refuses tagged commands. "
4684 "Performing non-tagged I/O\n", ahd_name(ahd),
4685 devinfo->channel, devinfo->target, devinfo->lun);
4686 ahd_set_tags(ahd, devinfo, AHD_QUEUE_NONE);
4687 mask = ~0x23;
4688 } else {
4689 printf("(%s:%c:%d:%d): refuses %s tagged commands. "
4690 "Performing simple queue tagged I/O only\n",
4691 ahd_name(ahd), devinfo->channel, devinfo->target,
4692 devinfo->lun, tag_type == MSG_ORDERED_Q_TAG
4693 ? "ordered" : "head of queue");
4694 ahd_set_tags(ahd, devinfo, AHD_QUEUE_BASIC);
4695 mask = ~0x03;
4696 }
4697
4698 /*
4699 * Resend the identify for this CCB as the target
4700 * may believe that the selection is invalid otherwise.
4701 */
4702 ahd_outb(ahd, SCB_CONTROL,
4703 ahd_inb_scbram(ahd, SCB_CONTROL) & mask);
4704 scb->hscb->control &= mask;
4705 ahd_set_transaction_tag(scb, /*enabled*/FALSE,
4706 /*type*/MSG_SIMPLE_TASK);
4707 ahd_outb(ahd, MSG_OUT, MSG_IDENTIFYFLAG);
4708 ahd_assert_atn(ahd);
4709 ahd_busy_tcl(ahd, BUILD_TCL(scb->hscb->scsiid, devinfo->lun),
4710 SCB_GET_TAG(scb));
4711
4712 /*
4713 * Requeue all tagged commands for this target
4714 * currently in our possession so they can be
4715 * converted to untagged commands.
4716 */
4717 ahd_search_qinfifo(ahd, SCB_GET_TARGET(ahd, scb),
4718 SCB_GET_CHANNEL(ahd, scb),
4719 SCB_GET_LUN(scb), /*tag*/SCB_LIST_NULL,
4720 ROLE_INITIATOR, CAM_REQUEUE_REQ,
4721 SEARCH_COMPLETE);
4722 } else if (ahd_sent_msg(ahd, AHDMSG_1B, MSG_IDENTIFYFLAG, TRUE)) {
4723 /*
4724 * Most likely the device believes that we had
4725 * previously negotiated packetized.
4726 */
4727 ahd->msg_flags |= MSG_FLAG_EXPECT_PPR_BUSFREE
4728 | MSG_FLAG_IU_REQ_CHANGED;
4729
4730 ahd_force_renegotiation(ahd, devinfo);
4731 ahd->msgout_index = 0;
4732 ahd->msgout_len = 0;
4733 ahd_build_transfer_msg(ahd, devinfo);
4734 ahd->msgout_index = 0;
4735 response = 1;
4736 } else {
4737 /*
4738 * Otherwise, we ignore it.
4739 */
4740 printf("%s:%c:%d: Message reject for %x -- ignored\n",
4741 ahd_name(ahd), devinfo->channel, devinfo->target,
4742 last_msg);
4743 }
4744 return (response);
4745 }
4746
4747 /*
4748 * Process an ignore wide residue message.
4749 */
4750 static void
4751 ahd_handle_ign_wide_residue(struct ahd_softc *ahd,
4752 struct ahd_devinfo *devinfo)
4753 {
4754 u_int scb_index;
4755 struct scb *scb;
4756
4757 printf("%s: ahd_handle_ign_wide_residue\n", ahd_name(ahd));
4758
4759 scb_index = ahd_get_scbptr(ahd);
4760 scb = ahd_lookup_scb(ahd, scb_index);
4761 /*
4762 * XXX Actually check data direction in the sequencer?
4763 * Perhaps add datadir to some spare bits in the hscb?
4764 */
4765 if ((ahd_inb(ahd, SEQ_FLAGS) & DPHASE) == 0
4766 || ahd_get_transfer_dir(scb) != CAM_DIR_IN) {
4767 /*
4768 * Ignore the message if we haven't
4769 * seen an appropriate data phase yet.
4770 */
4771 } else {
4772 /*
4773 * If the residual occurred on the last
4774 * transfer and the transfer request was
4775 * expected to end on an odd count, do
4776 * nothing. Otherwise, subtract a byte
4777 * and update the residual count accordingly.
4778 */
4779 uint32_t sgptr;
4780
4781 sgptr = ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR);
4782 if ((sgptr & SG_LIST_NULL) != 0
4783 && (ahd_inb_scbram(ahd, SCB_TASK_ATTRIBUTE)
4784 & SCB_XFERLEN_ODD) != 0) {
4785 /*
4786 * If the residual occurred on the last
4787 * transfer and the transfer request was
4788 * expected to end on an odd count, do
4789 * nothing.
4790 */
4791 } else {
4792 uint32_t data_cnt;
4793 uint64_t data_addr;
4794 uint32_t sglen;
4795
4796 /* Pull in the rest of the sgptr */
4797 sgptr = ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR);
4798 data_cnt = ahd_inl_scbram(ahd, SCB_RESIDUAL_DATACNT);
4799 if ((sgptr & SG_LIST_NULL) != 0) {
4800 /*
4801 * The residual data count is not updated
4802 * for the command run to completion case.
4803 * Explcitly zero the count.
4804 */
4805 data_cnt &= ~AHD_SG_LEN_MASK;
4806 }
4807 data_addr = ahd_inq(ahd, SHADDR);
4808 data_cnt += 1;
4809 data_addr -= 1;
4810 sgptr &= SG_PTR_MASK;
4811 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
4812 struct ahd_dma64_seg *sg;
4813
4814 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
4815
4816 /*
4817 * The residual sg ptr points to the next S/G
4818 * to load so we must go back one.
4819 */
4820 sg--;
4821 sglen = ahd_le32toh(sg->len) & AHD_SG_LEN_MASK;
4822 if (sg != scb->sg_list
4823 && sglen < (data_cnt & AHD_SG_LEN_MASK)) {
4824
4825 sg--;
4826 sglen = ahd_le32toh(sg->len);
4827 /*
4828 * Preserve High Address and SG_LIST
4829 * bits while setting the count to 1.
4830 */
4831 data_cnt = 1|(sglen&(~AHD_SG_LEN_MASK));
4832 data_addr = ahd_le64toh(sg->addr)
4833 + (sglen & AHD_SG_LEN_MASK)
4834 - 1;
4835
4836 /*
4837 * Increment sg so it points to the
4838 * "next" sg.
4839 */
4840 sg++;
4841 sgptr = ahd_sg_virt_to_bus(ahd, scb,
4842 sg);
4843 }
4844 } else {
4845 struct ahd_dma_seg *sg;
4846
4847 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
4848
4849 /*
4850 * The residual sg ptr points to the next S/G
4851 * to load so we must go back one.
4852 */
4853 sg--;
4854 sglen = ahd_le32toh(sg->len) & AHD_SG_LEN_MASK;
4855 if (sg != scb->sg_list
4856 && sglen < (data_cnt & AHD_SG_LEN_MASK)) {
4857
4858 sg--;
4859 sglen = ahd_le32toh(sg->len);
4860 /*
4861 * Preserve High Address and SG_LIST
4862 * bits while setting the count to 1.
4863 */
4864 data_cnt = 1|(sglen&(~AHD_SG_LEN_MASK));
4865 data_addr = ahd_le32toh(sg->addr)
4866 + (sglen & AHD_SG_LEN_MASK)
4867 - 1;
4868
4869 /*
4870 * Increment sg so it points to the
4871 * "next" sg.
4872 */
4873 sg++;
4874 sgptr = ahd_sg_virt_to_bus(ahd, scb,
4875 sg);
4876 }
4877 }
4878 /*
4879 * Toggle the "oddness" of the transfer length
4880 * to handle this mid-transfer ignore wide
4881 * residue. This ensures that the oddness is
4882 * correct for subsequent data transfers.
4883 */
4884 ahd_outb(ahd, SCB_TASK_ATTRIBUTE,
4885 ahd_inb_scbram(ahd, SCB_TASK_ATTRIBUTE)
4886 ^ SCB_XFERLEN_ODD);
4887
4888 ahd_outl(ahd, SCB_RESIDUAL_SGPTR, sgptr);
4889 ahd_outl(ahd, SCB_RESIDUAL_DATACNT, data_cnt);
4890 /*
4891 * The FIFO's pointers will be updated if/when the
4892 * sequencer re-enters a data phase.
4893 */
4894 }
4895 }
4896 }
4897
4898
4899 /*
4900 * Reinitialize the data pointers for the active transfer
4901 * based on its current residual.
4902 */
4903 static void
4904 ahd_reinitialize_dataptrs(struct ahd_softc *ahd)
4905 {
4906 struct scb *scb;
4907 ahd_mode_state saved_modes;
4908 u_int scb_index;
4909 u_int wait;
4910 uint32_t sgptr;
4911 uint32_t resid;
4912 uint64_t dataptr;
4913
4914 AHD_ASSERT_MODES(ahd, AHD_MODE_DFF0_MSK|AHD_MODE_DFF1_MSK,
4915 AHD_MODE_DFF0_MSK|AHD_MODE_DFF1_MSK);
4916
4917 scb_index = ahd_get_scbptr(ahd);
4918 scb = ahd_lookup_scb(ahd, scb_index);
4919
4920 /*
4921 * Release and reacquire the FIFO so we
4922 * have a clean slate.
4923 */
4924 ahd_outb(ahd, DFFSXFRCTL, CLRCHN);
4925 wait = 1000;
4926 while (--wait && !(ahd_inb(ahd, MDFFSTAT) & FIFOFREE))
4927 ahd_delay(100);
4928 if (wait == 0) {
4929 ahd_print_path(ahd, scb);
4930 printf("ahd_reinitialize_dataptrs: Forcing FIFO free.\n");
4931 ahd_outb(ahd, DFFSXFRCTL, RSTCHN|CLRSHCNT);
4932 }
4933 saved_modes = ahd_save_modes(ahd);
4934 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
4935 ahd_outb(ahd, DFFSTAT,
4936 ahd_inb(ahd, DFFSTAT)
4937 | (saved_modes == 0x11 ? CURRFIFO_1 : CURRFIFO_0));
4938
4939 /*
4940 * Determine initial values for data_addr and data_cnt
4941 * for resuming the data phase.
4942 */
4943 sgptr = (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 3) << 24)
4944 | (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 2) << 16)
4945 | (ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR + 1) << 8)
4946 | ahd_inb_scbram(ahd, SCB_RESIDUAL_SGPTR);
4947 sgptr &= SG_PTR_MASK;
4948
4949 resid = (ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT + 2) << 16)
4950 | (ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT + 1) << 8)
4951 | ahd_inb_scbram(ahd, SCB_RESIDUAL_DATACNT);
4952
4953 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
4954 struct ahd_dma64_seg *sg;
4955
4956 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
4957
4958 /* The residual sg_ptr always points to the next sg */
4959 sg--;
4960
4961 dataptr = ahd_le64toh(sg->addr)
4962 + (ahd_le32toh(sg->len) & AHD_SG_LEN_MASK)
4963 - resid;
4964 ahd_outb(ahd, HADDR + 7, dataptr >> 56);
4965 ahd_outb(ahd, HADDR + 6, dataptr >> 48);
4966 ahd_outb(ahd, HADDR + 5, dataptr >> 40);
4967 ahd_outb(ahd, HADDR + 4, dataptr >> 32);
4968 } else {
4969 struct ahd_dma_seg *sg;
4970
4971 sg = ahd_sg_bus_to_virt(ahd, scb, sgptr);
4972
4973 /* The residual sg_ptr always points to the next sg */
4974 sg--;
4975
4976 dataptr = ahd_le32toh(sg->addr)
4977 + (ahd_le32toh(sg->len) & AHD_SG_LEN_MASK)
4978 - resid;
4979 ahd_outb(ahd, HADDR + 4,
4980 (ahd_le32toh(sg->len) & ~AHD_SG_LEN_MASK) >> 24);
4981 }
4982 ahd_outb(ahd, HADDR + 3, dataptr >> 24);
4983 ahd_outb(ahd, HADDR + 2, dataptr >> 16);
4984 ahd_outb(ahd, HADDR + 1, dataptr >> 8);
4985 ahd_outb(ahd, HADDR, dataptr);
4986 ahd_outb(ahd, HCNT + 2, resid >> 16);
4987 ahd_outb(ahd, HCNT + 1, resid >> 8);
4988 ahd_outb(ahd, HCNT, resid);
4989 }
4990
4991 /*
4992 * Handle the effects of issuing a bus device reset message.
4993 */
4994 static void
4995 ahd_handle_devreset(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
4996 u_int lun, cam_status status, const char *message,
4997 int verbose_level)
4998 {
4999 #ifdef AHD_TARGET_MODE
5000 struct ahd_tmode_tstate* tstate;
5001 #endif
5002 int found;
5003
5004 found = ahd_abort_scbs(ahd, devinfo->target, devinfo->channel,
5005 lun, SCB_LIST_NULL, devinfo->role,
5006 status);
5007
5008 #ifdef AHD_TARGET_MODE
5009 /*
5010 * Send an immediate notify ccb to all target mord peripheral
5011 * drivers affected by this action.
5012 */
5013 tstate = ahd->enabled_targets[devinfo->our_scsiid];
5014 if (tstate != NULL) {
5015 u_int cur_lun;
5016 u_int max_lun;
5017
5018 if (lun != CAM_LUN_WILDCARD) {
5019 cur_lun = 0;
5020 max_lun = AHD_NUM_LUNS - 1;
5021 } else {
5022 cur_lun = lun;
5023 max_lun = lun;
5024 }
5025 for (cur_lun <= max_lun; cur_lun++) {
5026 struct ahd_tmode_lstate* lstate;
5027
5028 lstate = tstate->enabled_luns[cur_lun];
5029 if (lstate == NULL)
5030 continue;
5031
5032 ahd_queue_lstate_event(ahd, lstate, devinfo->our_scsiid,
5033 MSG_BUS_DEV_RESET, /*arg*/0);
5034 ahd_send_lstate_events(ahd, lstate);
5035 }
5036 }
5037 #endif
5038
5039 /*
5040 * Go back to async/narrow transfers and renegotiate.
5041 */
5042 ahd_set_width(ahd, devinfo, MSG_EXT_WDTR_BUS_8_BIT,
5043 AHD_TRANS_CUR, /*paused*/TRUE);
5044 ahd_set_syncrate(ahd, devinfo, /*period*/0, /*offset*/0,
5045 /*ppr_options*/0, AHD_TRANS_CUR, /*paused*/TRUE);
5046
5047 ahd_send_async(ahd, devinfo->channel, devinfo->target,
5048 lun, AC_SENT_BDR, NULL);
5049
5050 if (message != NULL
5051 && (verbose_level <= bootverbose))
5052 printf("%s: %s on %c:%d. %d SCBs aborted\n", ahd_name(ahd),
5053 message, devinfo->channel, devinfo->target, found);
5054 }
5055
5056 #ifdef AHD_TARGET_MODE
5057 static void
5058 ahd_setup_target_msgin(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
5059 struct scb *scb)
5060 {
5061
5062 /*
5063 * To facilitate adding multiple messages together,
5064 * each routine should increment the index and len
5065 * variables instead of setting them explicitly.
5066 */
5067 ahd->msgout_index = 0;
5068 ahd->msgout_len = 0;
5069
5070 if (scb != NULL && (scb->flags & SCB_AUTO_NEGOTIATE) != 0)
5071 ahd_build_transfer_msg(ahd, devinfo);
5072 else
5073 panic("ahd_intr: AWAITING target message with no message");
5074
5075 ahd->msgout_index = 0;
5076 ahd->msg_type = MSG_TYPE_TARGET_MSGIN;
5077 }
5078 #endif
5079 /**************************** Initialization **********************************/
5080 static u_int
5081 ahd_sglist_size(struct ahd_softc *ahd)
5082 {
5083 bus_size_t list_size;
5084
5085 list_size = sizeof(struct ahd_dma_seg) * AHD_NSEG;
5086 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0)
5087 list_size = sizeof(struct ahd_dma64_seg) * AHD_NSEG;
5088 return (list_size);
5089 }
5090
5091 /*
5092 * Calculate the optimum S/G List allocation size. S/G elements used
5093 * for a given transaction must be physically contiguous. Assume the
5094 * OS will allocate full pages to us, so it doesn't make sense to request
5095 * less than a page.
5096 */
5097 static u_int
5098 ahd_sglist_allocsize(struct ahd_softc *ahd)
5099 {
5100 bus_size_t sg_list_increment;
5101 bus_size_t sg_list_size;
5102 bus_size_t max_list_size;
5103 bus_size_t best_list_size;
5104
5105 /* Start out with the minimum required for AHD_NSEG. */
5106 sg_list_increment = ahd_sglist_size(ahd);
5107 sg_list_size = sg_list_increment;
5108
5109 /* Get us as close as possible to a page in size. */
5110 while ((sg_list_size + sg_list_increment) <= PAGE_SIZE)
5111 sg_list_size += sg_list_increment;
5112
5113 /*
5114 * Try to reduce the amount of wastage by allocating
5115 * multiple pages.
5116 */
5117 best_list_size = sg_list_size;
5118 max_list_size = roundup(sg_list_increment, PAGE_SIZE);
5119 if (max_list_size < 4 * PAGE_SIZE)
5120 max_list_size = 4 * PAGE_SIZE;
5121 if (max_list_size > (AHD_SCB_MAX_ALLOC * sg_list_increment))
5122 max_list_size = (AHD_SCB_MAX_ALLOC * sg_list_increment);
5123 while ((sg_list_size + sg_list_increment) <= max_list_size
5124 && (sg_list_size % PAGE_SIZE) != 0) {
5125 bus_size_t new_mod;
5126 bus_size_t best_mod;
5127
5128 sg_list_size += sg_list_increment;
5129 new_mod = sg_list_size % PAGE_SIZE;
5130 best_mod = best_list_size % PAGE_SIZE;
5131 if (new_mod > best_mod || new_mod == 0) {
5132 best_list_size = sg_list_size;
5133 }
5134 }
5135 return (best_list_size);
5136 }
5137
5138 int
5139 ahd_softc_init(struct ahd_softc *ahd)
5140 {
5141
5142 ahd->unpause = 0;
5143 ahd->pause = PAUSE;
5144 return (0);
5145 }
5146
5147 void
5148 ahd_set_unit(struct ahd_softc *ahd, int unit)
5149 {
5150 ahd->unit = unit;
5151 }
5152
5153 void
5154 ahd_set_name(struct ahd_softc *ahd, const char *name)
5155 {
5156 ahd->name = name;
5157 }
5158
5159 void
5160 ahd_free(struct ahd_softc *ahd)
5161 {
5162 int i;
5163
5164 switch (ahd->init_level) {
5165 default:
5166 case 2:
5167 ahd_shutdown(ahd);
5168 TAILQ_REMOVE(&ahd_tailq, ahd, links);
5169 /* FALLTHROUGH */
5170 case 1:
5171 bus_dmamap_unload(ahd->parent_dmat,
5172 ahd->shared_data_map.dmamap);
5173 bus_dmamap_destroy(ahd->parent_dmat,
5174 ahd->shared_data_map.dmamap);
5175 bus_dmamem_unmap(ahd->parent_dmat, (void *)ahd->qoutfifo,
5176 ahd->shared_data_size);
5177 bus_dmamem_free(ahd->parent_dmat,
5178 &ahd->shared_data_map.dmasegs, ahd->shared_data_map.nseg);
5179 break;
5180 case 0:
5181 break;
5182 }
5183
5184 ahd_platform_free(ahd);
5185 ahd_fini_scbdata(ahd);
5186 for (i = 0; i < AHD_NUM_TARGETS; i++) {
5187 struct ahd_tmode_tstate *tstate;
5188
5189 tstate = ahd->enabled_targets[i];
5190 if (tstate != NULL) {
5191 #if AHD_TARGET_MODE
5192 int j;
5193
5194 for (j = 0; j < AHD_NUM_LUNS; j++) {
5195 struct ahd_tmode_lstate *lstate;
5196
5197 lstate = tstate->enabled_luns[j];
5198 if (lstate != NULL) {
5199 xpt_free_path(lstate->path);
5200 free(lstate, M_DEVBUF);
5201 }
5202 }
5203 #endif
5204 free(tstate, M_DEVBUF);
5205 }
5206 }
5207 #if AHD_TARGET_MODE
5208 if (ahd->black_hole != NULL) {
5209 xpt_free_path(ahd->black_hole->path);
5210 free(ahd->black_hole, M_DEVBUF);
5211 }
5212 #endif
5213 if (ahd->seep_config != NULL)
5214 free(ahd->seep_config, M_DEVBUF);
5215 if (ahd->saved_stack != NULL)
5216 free(ahd->saved_stack, M_DEVBUF);
5217 #ifndef __FreeBSD__
5218 free(ahd, M_DEVBUF);
5219 #endif
5220 return;
5221 }
5222
5223 void
5224 ahd_shutdown(void *arg)
5225 {
5226 struct ahd_softc *ahd;
5227
5228 ahd = arg;
5229
5230 #ifdef AHD_DEBUG
5231 printf("%s: ahd_shutdown\n", ahd_name(ahd));
5232 #endif
5233 /*
5234 * Stop periodic timer callbacks.
5235 */
5236 ahd_timer_stop(&ahd->reset_timer);
5237 ahd_timer_stop(&ahd->stat_timer);
5238
5239 /* This will reset most registers to 0, but not all */
5240 ahd_reset(ahd, /*reinit*/FALSE);
5241 }
5242
5243 /*
5244 * Reset the controller and record some information about it
5245 * that is only available just after a reset. If "reinit" is
5246 * non-zero, this reset occurred after initial configuration
5247 * and the caller requests that the chip be fully reinitialized
5248 * to a runable state. Chip interrupts are *not* enabled after
5249 * a reinitialization. The caller must enable interrupts via
5250 * ahd_intr_enable().
5251 */
5252 int
5253 ahd_reset(struct ahd_softc *ahd, int reinit)
5254 {
5255 u_int sxfrctl1;
5256 int wait;
5257 uint32_t cmd;
5258 struct ahd_pci_busdata *bd = ahd->bus_data;
5259
5260 /*
5261 * Preserve the value of the SXFRCTL1 register for all channels.
5262 * It contains settings that affect termination and we don't want
5263 * to disturb the integrity of the bus.
5264 */
5265 ahd_pause(ahd);
5266 ahd_update_modes(ahd);
5267 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
5268 sxfrctl1 = ahd_inb(ahd, SXFRCTL1);
5269
5270 cmd = pci_conf_read(bd->pc, bd->tag, PCI_COMMAND_STATUS_REG);
5271
5272 if ((ahd->bugs & AHD_PCIX_CHIPRST_BUG) != 0) {
5273 uint32_t mod_cmd;
5274
5275 /*
5276 * A4 Razor #632
5277 * During the assertion of CHIPRST, the chip
5278 * does not disable its parity logic prior to
5279 * the start of the reset. This may cause a
5280 * parity error to be detected and thus a
5281 * spurious SERR or PERR assertion. Disble
5282 * PERR and SERR responses during the CHIPRST.
5283 */
5284 mod_cmd = cmd &
5285 ~(PCI_COMMAND_PARITY_ENABLE|PCI_COMMAND_SERR_ENABLE);
5286 pci_conf_write(bd->pc, bd->tag,
5287 PCI_COMMAND_STATUS_REG, mod_cmd);
5288 }
5289 ahd_outb(ahd, HCNTRL, CHIPRST | ahd->pause);
5290
5291 /*
5292 * Ensure that the reset has finished. We delay 1000us
5293 * prior to reading the register to make sure the chip
5294 * has sufficiently completed its reset to handle register
5295 * accesses.
5296 */
5297 wait = 1000;
5298 do {
5299 ahd_delay(1000);
5300 } while (--wait && !(ahd_inb(ahd, HCNTRL) & CHIPRSTACK));
5301
5302 if (wait == 0) {
5303 printf("%s: WARNING - Failed chip reset! "
5304 "Trying to initialize anyway.\n", ahd_name(ahd));
5305 }
5306 ahd_outb(ahd, HCNTRL, ahd->pause);
5307
5308 if ((ahd->bugs & AHD_PCIX_CHIPRST_BUG) != 0) {
5309 /*
5310 * Clear any latched PCI error status and restore
5311 * previous SERR and PERR response enables.
5312 */
5313 pci_conf_write(bd->pc, bd->tag, PCI_COMMAND_STATUS_REG, cmd |
5314 (PCI_STATUS_PARITY_ERROR | PCI_STATUS_TARGET_TARGET_ABORT |
5315 PCI_STATUS_MASTER_TARGET_ABORT | PCI_STATUS_MASTER_ABORT |
5316 PCI_STATUS_SPECIAL_ERROR));
5317 }
5318
5319 /*
5320 * Mode should be SCSI after a chip reset, but lets
5321 * set it just to be safe. We touch the MODE_PTR
5322 * register directly so as to bypass the lazy update
5323 * ode in ahd_set_modes().
5324 */
5325 ahd_known_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
5326 ahd_outb(ahd, MODE_PTR,
5327 ahd_build_mode_state(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI));
5328
5329 /*
5330 * Restore SXFRCTL1.
5331 *
5332 * We must always initialize STPWEN to 1 before we
5333 * restore the saved values. STPWEN is initialized
5334 * to a tri-state condition which can only be cleared
5335 * by turning it on.
5336 */
5337 ahd_outb(ahd, SXFRCTL1, sxfrctl1|STPWEN);
5338 ahd_outb(ahd, SXFRCTL1, sxfrctl1);
5339
5340 /* Determine chip configuration */
5341 ahd->features &= ~AHD_WIDE;
5342 if ((ahd_inb(ahd, SBLKCTL) & SELWIDE) != 0)
5343 ahd->features |= AHD_WIDE;
5344
5345 /*
5346 * If a recovery action has forced a chip reset,
5347 * re-initialize the chip to our liking.
5348 */
5349 if (reinit != 0)
5350 ahd_chip_init(ahd);
5351
5352 return (0);
5353 }
5354
5355 /*
5356 * Determine the number of SCBs available on the controller
5357 */
5358 int
5359 ahd_probe_scbs(struct ahd_softc *ahd) {
5360 int i;
5361
5362 AHD_ASSERT_MODES(ahd, ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK),
5363 ~(AHD_MODE_UNKNOWN_MSK|AHD_MODE_CFG_MSK));
5364 for (i = 0; i < AHD_SCB_MAX; i++) {
5365 int j;
5366 int ret;
5367
5368 ahd_set_scbptr(ahd, i);
5369 ahd_outw(ahd, SCB_BASE, i);
5370 for (j = 2; j < 64; j++)
5371 ahd_outb(ahd, SCB_BASE+j, 0);
5372 /* Start out life as unallocated (needing an abort) */
5373 ahd_outb(ahd, SCB_CONTROL, MK_MESSAGE);
5374 ret = ahd_inw_scbram(ahd, SCB_BASE);
5375 if (ret != i) {
5376 printf("%s: ahd_probe_scbs (!=%d): returned 0x%x\n",
5377 ahd_name(ahd), i, ret);
5378 break;
5379 }
5380 ahd_set_scbptr(ahd, 0);
5381 ret = ahd_inw_scbram(ahd, SCB_BASE);
5382 if (ret != 0) {
5383 printf("ahd_probe_scbs (non zero): returned 0x%x\n",
5384 ret);
5385 break;
5386 }
5387 }
5388 return (i);
5389 }
5390
5391 static void
5392 ahd_initialize_hscbs(struct ahd_softc *ahd)
5393 {
5394 int i;
5395
5396 for (i = 0; i < ahd->scb_data.maxhscbs; i++) {
5397 ahd_set_scbptr(ahd, i);
5398
5399 /* Clear the control byte. */
5400 ahd_outb(ahd, SCB_CONTROL, 0);
5401
5402 /* Set the next pointer */
5403 ahd_outw(ahd, SCB_NEXT, SCB_LIST_NULL);
5404 }
5405 }
5406
5407 static int
5408 ahd_init_scbdata(struct ahd_softc *ahd)
5409 {
5410 struct scb_data *scb_data;
5411 int i;
5412
5413 scb_data = &ahd->scb_data;
5414 TAILQ_INIT(&scb_data->free_scbs);
5415 for (i = 0; i < AHD_NUM_TARGETS * AHD_NUM_LUNS_NONPKT; i++)
5416 LIST_INIT(&scb_data->free_scb_lists[i]);
5417 LIST_INIT(&scb_data->any_dev_free_scb_list);
5418 SLIST_INIT(&scb_data->hscb_maps);
5419 SLIST_INIT(&scb_data->sg_maps);
5420 SLIST_INIT(&scb_data->sense_maps);
5421
5422 /* Determine the number of hardware SCBs and initialize them */
5423 scb_data->maxhscbs = ahd_probe_scbs(ahd);
5424 if (scb_data->maxhscbs == 0) {
5425 printf("%s: No SCB space found\n", ahd_name(ahd));
5426 return (ENXIO);
5427 }
5428 ahd_initialize_hscbs(ahd);
5429
5430 /*
5431 * Create our DMA tags. These tags define the kinds of device
5432 * accessible memory allocations and memory mappings we will
5433 * need to perform during normal operation.
5434 *
5435 * Unless we need to further restrict the allocation, we rely
5436 * on the restrictions of the parent dmat, hence the common
5437 * use of MAXADDR and MAXSIZE.
5438 */
5439
5440 /* Perform initial CCB allocation */
5441 ahd_alloc_scbs(ahd);
5442
5443 if (scb_data->numscbs == 0) {
5444 printf("%s: ahd_init_scbdata - "
5445 "Unable to allocate initial scbs\n",
5446 ahd_name(ahd));
5447 goto error_exit;
5448 }
5449
5450 /*
5451 * Note that we were successfull
5452 */
5453 return (0);
5454
5455 error_exit:
5456
5457 return (ENOMEM);
5458 }
5459
5460 static struct scb *
5461 ahd_find_scb_by_tag(struct ahd_softc *ahd, u_int tag)
5462 {
5463 struct scb *scb;
5464
5465 /*
5466 * Look on the pending list.
5467 */
5468 LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
5469 if (SCB_GET_TAG(scb) == tag)
5470 return (scb);
5471 }
5472
5473 /*
5474 * Then on all of the collision free lists.
5475 */
5476 TAILQ_FOREACH(scb, &ahd->scb_data.free_scbs, links.tqe) {
5477 struct scb *list_scb;
5478
5479 list_scb = scb;
5480 do {
5481 if (SCB_GET_TAG(list_scb) == tag)
5482 return (list_scb);
5483 list_scb = LIST_NEXT(list_scb, collision_links);
5484 } while (list_scb);
5485 }
5486
5487 /*
5488 * And finally on the generic free list.
5489 */
5490 LIST_FOREACH(scb, &ahd->scb_data.any_dev_free_scb_list, links.le) {
5491 if (SCB_GET_TAG(scb) == tag)
5492 return (scb);
5493 }
5494
5495 return (NULL);
5496 }
5497
5498 static void
5499 ahd_fini_scbdata(struct ahd_softc *ahd)
5500 {
5501 struct scb_data *scb_data;
5502
5503 scb_data = &ahd->scb_data;
5504 if (scb_data == NULL)
5505 return;
5506
5507 switch (scb_data->init_level) {
5508 default:
5509 case 3:
5510 {
5511 struct map_node *sns_map;
5512
5513 while ((sns_map = SLIST_FIRST(&scb_data->sense_maps)) != NULL) {
5514 SLIST_REMOVE_HEAD(&scb_data->sense_maps, links);
5515 ahd_freedmamem(ahd->parent_dmat, PAGE_SIZE,
5516 sns_map->dmamap, (void *)sns_map->vaddr,
5517 &sns_map->dmasegs, sns_map->nseg);
5518 free(sns_map, M_DEVBUF);
5519 }
5520 /* FALLTHROUGH */
5521 }
5522 case 2:
5523 {
5524 struct map_node *sg_map;
5525
5526 while ((sg_map = SLIST_FIRST(&scb_data->sg_maps)) != NULL) {
5527 SLIST_REMOVE_HEAD(&scb_data->sg_maps, links);
5528 ahd_freedmamem(ahd->parent_dmat,
5529 ahd_sglist_allocsize(ahd),
5530 sg_map->dmamap, (void *)sg_map->vaddr,
5531 &sg_map->dmasegs, sg_map->nseg);
5532 free(sg_map, M_DEVBUF);
5533 }
5534 /* FALLTHROUGH */
5535 }
5536 case 1:
5537 {
5538 struct map_node *hscb_map;
5539
5540 while ((hscb_map = SLIST_FIRST(&scb_data->hscb_maps)) != NULL) {
5541 SLIST_REMOVE_HEAD(&scb_data->hscb_maps, links);
5542 ahd_freedmamem(ahd->parent_dmat, PAGE_SIZE,
5543 hscb_map->dmamap,
5544 (void *)hscb_map->vaddr,
5545 &hscb_map->dmasegs, hscb_map->nseg);
5546 free(hscb_map, M_DEVBUF);
5547 }
5548 /* FALLTHROUGH */
5549 }
5550 case 0:
5551 break;
5552 }
5553 }
5554
5555 /*
5556 * DSP filter Bypass must be enabled until the first selection
5557 * after a change in bus mode (Razor #491 and #493).
5558 */
5559 static void
5560 ahd_setup_iocell_workaround(struct ahd_softc *ahd)
5561 {
5562 ahd_mode_state saved_modes;
5563
5564 saved_modes = ahd_save_modes(ahd);
5565 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
5566 ahd_outb(ahd, DSPDATACTL, ahd_inb(ahd, DSPDATACTL)
5567 | BYPASSENAB | RCVROFFSTDIS | XMITOFFSTDIS);
5568 ahd_outb(ahd, SIMODE0, ahd_inb(ahd, SIMODE0) | (ENSELDO|ENSELDI));
5569 #ifdef AHD_DEBUG
5570 if ((ahd_debug & AHD_SHOW_MISC) != 0)
5571 printf("%s: Setting up iocell workaround\n", ahd_name(ahd));
5572 #endif
5573 ahd_restore_modes(ahd, saved_modes);
5574 ahd->flags &= ~AHD_HAD_FIRST_SEL;
5575 }
5576
5577 static void
5578 ahd_iocell_first_selection(struct ahd_softc *ahd)
5579 {
5580 ahd_mode_state saved_modes;
5581 u_int sblkctl;
5582
5583 if ((ahd->flags & AHD_HAD_FIRST_SEL) != 0)
5584 return;
5585 saved_modes = ahd_save_modes(ahd);
5586 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
5587 sblkctl = ahd_inb(ahd, SBLKCTL);
5588 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
5589 #ifdef AHD_DEBUG
5590 if ((ahd_debug & AHD_SHOW_MISC) != 0)
5591 printf("%s: iocell first selection\n", ahd_name(ahd));
5592 #endif
5593 if ((sblkctl & ENAB40) != 0) {
5594 ahd_outb(ahd, DSPDATACTL,
5595 ahd_inb(ahd, DSPDATACTL) & ~BYPASSENAB);
5596 #ifdef AHD_DEBUG
5597 if ((ahd_debug & AHD_SHOW_MISC) != 0)
5598 printf("%s: BYPASS now disabled\n", ahd_name(ahd));
5599 #endif
5600 }
5601 ahd_outb(ahd, SIMODE0, ahd_inb(ahd, SIMODE0) & ~(ENSELDO|ENSELDI));
5602 ahd_outb(ahd, CLRINT, CLRSCSIINT);
5603 ahd_restore_modes(ahd, saved_modes);
5604 ahd->flags |= AHD_HAD_FIRST_SEL;
5605 }
5606
5607 /*************************** SCB Management ***********************************/
5608 static void
5609 ahd_add_col_list(struct ahd_softc *ahd, struct scb *scb, u_int col_idx)
5610 {
5611 struct scb_list *free_list;
5612 struct scb_tailq *free_tailq;
5613 struct scb *first_scb;
5614
5615 scb->flags |= SCB_ON_COL_LIST;
5616 AHD_SET_SCB_COL_IDX(scb, col_idx);
5617 free_list = &ahd->scb_data.free_scb_lists[col_idx];
5618 free_tailq = &ahd->scb_data.free_scbs;
5619 first_scb = LIST_FIRST(free_list);
5620 if (first_scb != NULL) {
5621 LIST_INSERT_AFTER(first_scb, scb, collision_links);
5622 } else {
5623 LIST_INSERT_HEAD(free_list, scb, collision_links);
5624 TAILQ_INSERT_TAIL(free_tailq, scb, links.tqe);
5625 }
5626 }
5627
5628 static void
5629 ahd_rem_col_list(struct ahd_softc *ahd, struct scb *scb)
5630 {
5631 struct scb_list *free_list;
5632 struct scb_tailq *free_tailq;
5633 struct scb *first_scb;
5634 u_int col_idx;
5635
5636 scb->flags &= ~SCB_ON_COL_LIST;
5637 col_idx = AHD_GET_SCB_COL_IDX(ahd, scb);
5638 free_list = &ahd->scb_data.free_scb_lists[col_idx];
5639 free_tailq = &ahd->scb_data.free_scbs;
5640 first_scb = LIST_FIRST(free_list);
5641 if (first_scb == scb) {
5642 struct scb *next_scb;
5643
5644 /*
5645 * Maintain order in the collision free
5646 * lists for fairness if this device has
5647 * other colliding tags active.
5648 */
5649 next_scb = LIST_NEXT(scb, collision_links);
5650 if (next_scb != NULL) {
5651 TAILQ_INSERT_AFTER(free_tailq, scb,
5652 next_scb, links.tqe);
5653 }
5654 TAILQ_REMOVE(free_tailq, scb, links.tqe);
5655 }
5656 LIST_REMOVE(scb, collision_links);
5657 }
5658
5659 /*
5660 * Get a free scb. If there are none, see if we can allocate a new SCB.
5661 */
5662 struct scb *
5663 ahd_get_scb(struct ahd_softc *ahd, u_int col_idx)
5664 {
5665 struct scb *scb;
5666 TAILQ_FOREACH(scb, &ahd->scb_data.free_scbs, links.tqe) {
5667 if (AHD_GET_SCB_COL_IDX(ahd, scb) != col_idx) {
5668 ahd_rem_col_list(ahd, scb);
5669 goto found;
5670 }
5671 }
5672 if ((scb = LIST_FIRST(&ahd->scb_data.any_dev_free_scb_list)) == NULL)
5673 return (NULL);
5674 LIST_REMOVE(scb, links.le);
5675 if (col_idx != AHD_NEVER_COL_IDX
5676 && (scb->col_scb != NULL)
5677 && (scb->col_scb->flags & SCB_ACTIVE) == 0) {
5678 LIST_REMOVE(scb->col_scb, links.le);
5679 ahd_add_col_list(ahd, scb->col_scb, col_idx);
5680 }
5681 found:
5682 scb->flags |= SCB_ACTIVE;
5683 return (scb);
5684 }
5685
5686 /*
5687 * Return an SCB resource to the free list.
5688 */
5689 void
5690 ahd_free_scb(struct ahd_softc *ahd, struct scb *scb)
5691 {
5692
5693 /* Clean up for the next user */
5694 scb->flags = SCB_FLAG_NONE;
5695 scb->hscb->control = 0;
5696 ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = NULL;
5697
5698 if (scb->col_scb == NULL) {
5699
5700 /*
5701 * No collision possible. Just free normally.
5702 */
5703 LIST_INSERT_HEAD(&ahd->scb_data.any_dev_free_scb_list,
5704 scb, links.le);
5705 } else if ((scb->col_scb->flags & SCB_ON_COL_LIST) != 0) {
5706
5707 /*
5708 * The SCB we might have collided with is on
5709 * a free collision list. Put both SCBs on
5710 * the generic list.
5711 */
5712 ahd_rem_col_list(ahd, scb->col_scb);
5713 LIST_INSERT_HEAD(&ahd->scb_data.any_dev_free_scb_list,
5714 scb, links.le);
5715 LIST_INSERT_HEAD(&ahd->scb_data.any_dev_free_scb_list,
5716 scb->col_scb, links.le);
5717 } else if ((scb->col_scb->flags
5718 & (SCB_PACKETIZED|SCB_ACTIVE)) == SCB_ACTIVE
5719 && (scb->col_scb->hscb->control & TAG_ENB) != 0) {
5720
5721 /*
5722 * The SCB we might collide with on the next allocation
5723 * is still active in a non-packetized, tagged, context.
5724 * Put us on the SCB collision list.
5725 */
5726 ahd_add_col_list(ahd, scb,
5727 AHD_GET_SCB_COL_IDX(ahd, scb->col_scb));
5728 } else {
5729 /*
5730 * The SCB we might collide with on the next allocation
5731 * is either active in a packetized context, or free.
5732 * Since we can't collide, put this SCB on the generic
5733 * free list.
5734 */
5735 LIST_INSERT_HEAD(&ahd->scb_data.any_dev_free_scb_list,
5736 scb, links.le);
5737 }
5738
5739 ahd_platform_scb_free(ahd, scb);
5740 }
5741
5742 int
5743 ahd_alloc_scbs(struct ahd_softc *ahd)
5744 {
5745 struct scb_data *scb_data;
5746 struct scb *next_scb;
5747 struct hardware_scb *hscb;
5748 struct map_node *hscb_map;
5749 struct map_node *sg_map;
5750 struct map_node *sense_map;
5751 uint8_t *segs;
5752 uint8_t *sense_data;
5753 bus_addr_t hscb_busaddr;
5754 bus_addr_t sg_busaddr;
5755 bus_addr_t sense_busaddr;
5756 int newcount;
5757 int i;
5758
5759 scb_data = &ahd->scb_data;
5760 if (scb_data->numscbs >= AHD_SCB_MAX_ALLOC)
5761 /* Can't allocate any more */
5762 return (0);
5763
5764 KASSERT(scb_data->scbs_left >= 0);
5765 if (scb_data->scbs_left != 0) {
5766 int offset;
5767
5768 offset = (PAGE_SIZE / sizeof(*hscb)) - scb_data->scbs_left;
5769 hscb_map = SLIST_FIRST(&scb_data->hscb_maps);
5770 hscb = &((struct hardware_scb *)hscb_map->vaddr)[offset];
5771 hscb_busaddr = hscb_map->physaddr + (offset * sizeof(*hscb));
5772 } else {
5773 hscb_map = malloc(sizeof(*hscb_map), M_DEVBUF, M_WAITOK);
5774
5775 if (hscb_map == NULL)
5776 return (0);
5777
5778 memset(hscb_map, 0, sizeof(*hscb_map));
5779
5780 /* Allocate the next batch of hardware SCBs */
5781 if (ahd_createdmamem(ahd->parent_dmat, PAGE_SIZE,
5782 ahd->sc_dmaflags,
5783 &hscb_map->dmamap,
5784 (void **)&hscb_map->vaddr,
5785 &hscb_map->physaddr, &hscb_map->dmasegs,
5786 &hscb_map->nseg, ahd_name(ahd),
5787 "hardware SCB structures") < 0) {
5788 free(hscb_map, M_DEVBUF);
5789 return (0);
5790 }
5791
5792 SLIST_INSERT_HEAD(&scb_data->hscb_maps, hscb_map, links);
5793
5794 hscb = (struct hardware_scb *)hscb_map->vaddr;
5795 hscb_busaddr = hscb_map->physaddr;
5796 scb_data->scbs_left = PAGE_SIZE / sizeof(*hscb);
5797 }
5798
5799 scb_data->init_level++;
5800
5801 if (scb_data->sgs_left != 0) {
5802 int offset;
5803
5804 offset = ((ahd_sglist_allocsize(ahd) / ahd_sglist_size(ahd))
5805 - scb_data->sgs_left) * ahd_sglist_size(ahd);
5806 sg_map = SLIST_FIRST(&scb_data->sg_maps);
5807 segs = sg_map->vaddr + offset;
5808 sg_busaddr = sg_map->physaddr + offset;
5809 } else {
5810 sg_map = malloc(sizeof(*sg_map), M_DEVBUF, M_WAITOK);
5811
5812 if (sg_map == NULL)
5813 return (0);
5814
5815 memset(sg_map, 0, sizeof(*sg_map));
5816
5817 /* Allocate the next batch of S/G lists */
5818 if (ahd_createdmamem(ahd->parent_dmat,
5819 ahd_sglist_allocsize(ahd),
5820 ahd->sc_dmaflags,
5821 &sg_map->dmamap, (void **)&sg_map->vaddr,
5822 &sg_map->physaddr, &sg_map->dmasegs,
5823 &sg_map->nseg, ahd_name(ahd),
5824 "SG data structures") < 0) {
5825 free(sg_map, M_DEVBUF);
5826 return (0);
5827 }
5828
5829 SLIST_INSERT_HEAD(&scb_data->sg_maps, sg_map, links);
5830
5831 segs = sg_map->vaddr;
5832 sg_busaddr = sg_map->physaddr;
5833 scb_data->sgs_left =
5834 ahd_sglist_allocsize(ahd) / ahd_sglist_size(ahd);
5835 #ifdef AHD_DEBUG
5836 if (ahd_debug & AHD_SHOW_MEMORY)
5837 printf("%s: ahd_alloc_scbs - Mapped SG data\n",
5838 ahd_name(ahd));
5839 #endif
5840 }
5841
5842 scb_data->init_level++;
5843
5844
5845 if (scb_data->sense_left != 0) {
5846 int offset;
5847
5848 offset = PAGE_SIZE - (AHD_SENSE_BUFSIZE * scb_data->sense_left);
5849 sense_map = SLIST_FIRST(&scb_data->sense_maps);
5850 sense_data = sense_map->vaddr + offset;
5851 sense_busaddr = sense_map->physaddr + offset;
5852 } else {
5853 sense_map = malloc(sizeof(*sense_map), M_DEVBUF, M_WAITOK);
5854
5855 if (sense_map == NULL)
5856 return (0);
5857
5858 memset(sense_map, 0, sizeof(*sense_map));
5859
5860 /* Allocate the next batch of sense buffers */
5861 if (ahd_createdmamem(ahd->parent_dmat, PAGE_SIZE,
5862 ahd->sc_dmaflags,
5863 &sense_map->dmamap,
5864 (void **)&sense_map->vaddr,
5865 &sense_map->physaddr, &sense_map->dmasegs,
5866 &sense_map->nseg, ahd_name(ahd),
5867 "Sense Data structures") < 0) {
5868 free(sense_map, M_DEVBUF);
5869 return (0);
5870 }
5871
5872 SLIST_INSERT_HEAD(&scb_data->sense_maps, sense_map, links);
5873
5874 sense_data = sense_map->vaddr;
5875 sense_busaddr = sense_map->physaddr;
5876 scb_data->sense_left = PAGE_SIZE / AHD_SENSE_BUFSIZE;
5877 #ifdef AHD_DEBUG
5878 if (ahd_debug & AHD_SHOW_MEMORY)
5879 printf("%s: ahd_alloc_scbs - Mapped sense data\n",
5880 ahd_name(ahd));
5881 #endif
5882 }
5883
5884 scb_data->init_level++;
5885
5886 newcount = MIN(scb_data->sense_left, scb_data->scbs_left);
5887 newcount = MIN(newcount, scb_data->sgs_left);
5888 newcount = MIN(newcount, (AHD_SCB_MAX_ALLOC - scb_data->numscbs));
5889 scb_data->sense_left -= newcount;
5890 scb_data->scbs_left -= newcount;
5891 scb_data->sgs_left -= newcount;
5892
5893 for (i = 0; i < newcount; i++) {
5894 u_int col_tag;
5895
5896 struct scb_platform_data *pdata;
5897 #ifndef __linux__
5898 int error;
5899 #endif
5900 next_scb = malloc(sizeof(*next_scb), M_DEVBUF, M_WAITOK);
5901 if (next_scb == NULL)
5902 break;
5903
5904 pdata = malloc(sizeof(*pdata), M_DEVBUF, M_WAITOK);
5905 if (pdata == NULL) {
5906 free(next_scb, M_DEVBUF);
5907 break;
5908 }
5909 next_scb->platform_data = pdata;
5910 next_scb->hscb_map = hscb_map;
5911 next_scb->sg_map = sg_map;
5912 next_scb->sense_map = sense_map;
5913 next_scb->sg_list = segs;
5914 next_scb->sense_data = sense_data;
5915 next_scb->sense_busaddr = sense_busaddr;
5916 memset(hscb, 0, sizeof(*hscb));
5917 next_scb->hscb = hscb;
5918 hscb->hscb_busaddr = ahd_htole32(hscb_busaddr);
5919 KASSERT((vaddr_t)hscb >= (vaddr_t)hscb_map->vaddr &&
5920 (vaddr_t)hscb < (vaddr_t)hscb_map->vaddr + PAGE_SIZE);
5921
5922 /*
5923 * The sequencer always starts with the second entry.
5924 * The first entry is embedded in the scb.
5925 */
5926 next_scb->sg_list_busaddr = sg_busaddr;
5927 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0)
5928 next_scb->sg_list_busaddr
5929 += sizeof(struct ahd_dma64_seg);
5930 else
5931 next_scb->sg_list_busaddr += sizeof(struct ahd_dma_seg);
5932 next_scb->ahd_softc = ahd;
5933 next_scb->flags = SCB_FLAG_NONE;
5934
5935 error = bus_dmamap_create(ahd->parent_dmat,
5936 AHD_MAXTRANSFER_SIZE, AHD_NSEG,
5937 MAXBSIZE, 0,
5938 BUS_DMA_WAITOK|BUS_DMA_ALLOCNOW|
5939 ahd->sc_dmaflags,
5940 &next_scb->dmamap);
5941 if (error != 0) {
5942 free(next_scb, M_DEVBUF);
5943 free(pdata, M_DEVBUF);
5944 break;
5945 }
5946 next_scb->hscb->tag = ahd_htole16(scb_data->numscbs);
5947 col_tag = scb_data->numscbs ^ 0x100;
5948 next_scb->col_scb = ahd_find_scb_by_tag(ahd, col_tag);
5949 if (next_scb->col_scb != NULL)
5950 next_scb->col_scb->col_scb = next_scb;
5951 ahd_free_scb(ahd, next_scb);
5952 hscb++;
5953 hscb_busaddr += sizeof(*hscb);
5954 segs += ahd_sglist_size(ahd);
5955 sg_busaddr += ahd_sglist_size(ahd);
5956 sense_data += AHD_SENSE_BUFSIZE;
5957 sense_busaddr += AHD_SENSE_BUFSIZE;
5958 scb_data->numscbs++;
5959 }
5960 return (i);
5961 }
5962
5963 void
5964 ahd_controller_info(struct ahd_softc *ahd, char *tbuf, size_t l)
5965 {
5966 const char *speed;
5967 const char *type;
5968 int len;
5969 char *ep;
5970
5971 ep = tbuf + l;
5972
5973 len = snprintf(tbuf, ep - tbuf, "%s: ",
5974 ahd_chip_names[ahd->chip & AHD_CHIPID_MASK]);
5975 tbuf += len;
5976
5977 speed = "Ultra320 ";
5978 if ((ahd->features & AHD_WIDE) != 0) {
5979 type = "Wide ";
5980 } else {
5981 type = "Single ";
5982 }
5983 len = snprintf(tbuf, ep - tbuf, "%s%sChannel %c, SCSI Id=%d, ",
5984 speed, type, ahd->channel, ahd->our_id);
5985 tbuf += len;
5986
5987 snprintf(tbuf, ep - tbuf, "%s, %d SCBs", ahd->bus_description,
5988 ahd->scb_data.maxhscbs);
5989 }
5990
5991 static const char *channel_strings[] = {
5992 "Primary Low",
5993 "Primary High",
5994 "Secondary Low",
5995 "Secondary High"
5996 };
5997
5998 static const char *termstat_strings[] = {
5999 "Terminated Correctly",
6000 "Over Terminated",
6001 "Under Terminated",
6002 "Not Configured"
6003 };
6004
6005 /*
6006 * Start the board, ready for normal operation
6007 */
6008 int
6009 ahd_init(struct ahd_softc *ahd)
6010 {
6011 uint8_t *next_vaddr;
6012 bus_addr_t next_baddr;
6013 size_t driver_data_size;
6014 int i;
6015 int error;
6016 u_int warn_user;
6017 uint8_t current_sensing;
6018 uint8_t fstat;
6019
6020 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
6021
6022 ahd->stack_size = ahd_probe_stack_size(ahd);
6023 ahd->saved_stack = malloc(ahd->stack_size * sizeof(uint16_t),
6024 M_DEVBUF, M_NOWAIT);
6025 if (ahd->saved_stack == NULL)
6026 return (ENOMEM);
6027 /* Zero the memory */
6028 memset(ahd->saved_stack, 0, ahd->stack_size * sizeof(uint16_t));
6029
6030 /*
6031 * Verify that the compiler hasn't over-agressively
6032 * padded important structures.
6033 */
6034 if (sizeof(struct hardware_scb) != 64)
6035 panic("Hardware SCB size is incorrect");
6036
6037 #ifdef AHD_DEBUG
6038 if ((ahd_debug & AHD_DEBUG_SEQUENCER) != 0)
6039 ahd->flags |= AHD_SEQUENCER_DEBUG;
6040 #endif
6041
6042 /*
6043 * Default to allowing initiator operations.
6044 */
6045 ahd->flags |= AHD_INITIATORROLE;
6046
6047 /*
6048 * Only allow target mode features if this unit has them enabled.
6049 */
6050 if ((AHD_TMODE_ENABLE & (0x1 << ahd->unit)) == 0)
6051 ahd->features &= ~AHD_TARGETMODE;
6052
6053 /*
6054 * DMA tag for our command fifos and other data in system memory
6055 * the card's sequencer must be able to access. For initiator
6056 * roles, we need to allocate space for the qoutfifo. When providing
6057 * for the target mode role, we must additionally provide space for
6058 * the incoming target command fifo.
6059 */
6060 driver_data_size = AHD_SCB_MAX * sizeof(uint16_t)
6061 + sizeof(struct hardware_scb);
6062 if ((ahd->features & AHD_TARGETMODE) != 0)
6063 driver_data_size += AHD_TMODE_CMDS * sizeof(struct target_cmd);
6064 if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0)
6065 driver_data_size += PKT_OVERRUN_BUFSIZE;
6066 ahd->shared_data_size = driver_data_size;
6067
6068 memset(&ahd->shared_data_map, 0, sizeof(ahd->shared_data_map));
6069 ahd->sc_dmaflags = BUS_DMA_NOWAIT;
6070
6071 if (ahd_createdmamem(ahd->parent_dmat, ahd->shared_data_size,
6072 ahd->sc_dmaflags,
6073 &ahd->shared_data_map.dmamap,
6074 (void **)&ahd->shared_data_map.vaddr,
6075 &ahd->shared_data_map.physaddr,
6076 &ahd->shared_data_map.dmasegs,
6077 &ahd->shared_data_map.nseg, ahd_name(ahd),
6078 "shared data") < 0)
6079 return (ENOMEM);
6080 ahd->qoutfifo = (void *) ahd->shared_data_map.vaddr;
6081
6082 ahd->init_level++;
6083
6084 next_vaddr = (uint8_t *)&ahd->qoutfifo[AHD_QOUT_SIZE];
6085 next_baddr = ahd->shared_data_map.physaddr +
6086 AHD_QOUT_SIZE * sizeof(uint16_t);
6087 if ((ahd->features & AHD_TARGETMODE) != 0) {
6088 ahd->targetcmds = (struct target_cmd *)next_vaddr;
6089 next_vaddr += AHD_TMODE_CMDS * sizeof(struct target_cmd);
6090 next_baddr += AHD_TMODE_CMDS * sizeof(struct target_cmd);
6091 }
6092
6093 if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0) {
6094 ahd->overrun_buf = next_vaddr;
6095 next_vaddr += PKT_OVERRUN_BUFSIZE;
6096 next_baddr += PKT_OVERRUN_BUFSIZE;
6097 }
6098
6099 /*
6100 * We need one SCB to serve as the "next SCB". Since the
6101 * tag identifier in this SCB will never be used, there is
6102 * no point in using a valid HSCB tag from an SCB pulled from
6103 * the standard free pool. So, we allocate this "sentinel"
6104 * specially from the DMA safe memory chunk used for the QOUTFIFO.
6105 */
6106 ahd->next_queued_hscb = (struct hardware_scb *)next_vaddr;
6107 ahd->next_queued_hscb_map = &ahd->shared_data_map;
6108 ahd->next_queued_hscb->hscb_busaddr = ahd_htole32(next_baddr);
6109
6110 memset(&ahd->scb_data, 0, sizeof(struct scb_data));
6111
6112 /* Allocate SCB data now that parent_dmat is initialized */
6113 if (ahd_init_scbdata(ahd) != 0)
6114 return (ENOMEM);
6115
6116 if ((ahd->flags & AHD_INITIATORROLE) == 0)
6117 ahd->flags &= ~AHD_RESET_BUS_A;
6118
6119 /*
6120 * Before committing these settings to the chip, give
6121 * the OSM one last chance to modify our configuration.
6122 */
6123 ahd_platform_init(ahd);
6124
6125 /* Bring up the chip. */
6126 ahd_chip_init(ahd);
6127
6128 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
6129
6130 if ((ahd->flags & AHD_CURRENT_SENSING) == 0)
6131 goto init_done;
6132
6133 /*
6134 * Verify termination based on current draw and
6135 * warn user if the bus is over/under terminated.
6136 */
6137 error = ahd_write_flexport(ahd, FLXADDR_ROMSTAT_CURSENSECTL,
6138 CURSENSE_ENB);
6139 if (error != 0) {
6140 printf("%s: current sensing timeout 1\n", ahd_name(ahd));
6141 goto init_done;
6142 }
6143 for (i = 20, fstat = FLX_FSTAT_BUSY;
6144 (fstat & FLX_FSTAT_BUSY) != 0 && i; i--) {
6145 error = ahd_read_flexport(ahd, FLXADDR_FLEXSTAT, &fstat);
6146 if (error != 0) {
6147 printf("%s: current sensing timeout 2\n",
6148 ahd_name(ahd));
6149 goto init_done;
6150 }
6151 }
6152 if (i == 0) {
6153 printf("%s: Timedout during current-sensing test\n",
6154 ahd_name(ahd));
6155 goto init_done;
6156 }
6157
6158 /* Latch Current Sensing status. */
6159 error = ahd_read_flexport(ahd, FLXADDR_CURRENT_STAT, &current_sensing);
6160 if (error != 0) {
6161 printf("%s: current sensing timeout 3\n", ahd_name(ahd));
6162 goto init_done;
6163 }
6164
6165 /* Diable current sensing. */
6166 ahd_write_flexport(ahd, FLXADDR_ROMSTAT_CURSENSECTL, 0);
6167
6168 #ifdef AHD_DEBUG
6169 if ((ahd_debug & AHD_SHOW_TERMCTL) != 0) {
6170 printf("%s: current_sensing == 0x%x\n",
6171 ahd_name(ahd), current_sensing);
6172 }
6173 #endif
6174 warn_user = 0;
6175 for (i = 0; i < 4; i++, current_sensing >>= FLX_CSTAT_SHIFT) {
6176 u_int term_stat;
6177
6178 term_stat = (current_sensing & FLX_CSTAT_MASK);
6179 switch (term_stat) {
6180 case FLX_CSTAT_OVER:
6181 case FLX_CSTAT_UNDER:
6182 warn_user++;
6183 case FLX_CSTAT_INVALID:
6184 case FLX_CSTAT_OKAY:
6185 if (warn_user == 0 && bootverbose == 0)
6186 break;
6187 printf("%s: %s Channel %s\n", ahd_name(ahd),
6188 channel_strings[i], termstat_strings[term_stat]);
6189 break;
6190 }
6191 }
6192 if (warn_user) {
6193 printf("%s: WARNING. Termination is not configured correctly.\n"
6194 "%s: WARNING. SCSI bus operations may FAIL.\n",
6195 ahd_name(ahd), ahd_name(ahd));
6196 }
6197 init_done:
6198 ahd_reset_current_bus(ahd);
6199 ahd_restart(ahd);
6200 ahd_timer_reset(&ahd->stat_timer, AHD_STAT_UPDATE_US,
6201 ahd_stat_timer, ahd);
6202
6203 return (0);
6204 }
6205
6206 /*
6207 * (Re)initialize chip state after a chip reset.
6208 */
6209 static void
6210 ahd_chip_init(struct ahd_softc *ahd)
6211 {
6212 uint32_t busaddr;
6213 u_int sxfrctl1;
6214 u_int scsiseq_template;
6215 u_int wait;
6216 u_int i;
6217 u_int target;
6218
6219 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
6220 /*
6221 * Take the LED out of diagnostic mode
6222 */
6223 ahd_outb(ahd, SBLKCTL, ahd_inb(ahd, SBLKCTL) & ~(DIAGLEDEN|DIAGLEDON));
6224
6225 /*
6226 * Return HS_MAILBOX to its default value.
6227 */
6228 ahd->hs_mailbox = 0;
6229 ahd_outb(ahd, HS_MAILBOX, 0);
6230
6231 /* Set the SCSI Id, SXFRCTL0, SXFRCTL1, and SIMODE1. */
6232 ahd_outb(ahd, IOWNID, ahd->our_id);
6233 ahd_outb(ahd, TOWNID, ahd->our_id);
6234 sxfrctl1 = (ahd->flags & AHD_TERM_ENB_A) != 0 ? STPWEN : 0;
6235 sxfrctl1 |= (ahd->flags & AHD_SPCHK_ENB_A) != 0 ? ENSPCHK : 0;
6236 if ((ahd->bugs & AHD_LONG_SETIMO_BUG)
6237 && (ahd->seltime != STIMESEL_MIN)) {
6238 /*
6239 * The selection timer duration is twice as long
6240 * as it should be. Halve it by adding "1" to
6241 * the user specified setting.
6242 */
6243 sxfrctl1 |= ahd->seltime + STIMESEL_BUG_ADJ;
6244 } else {
6245 sxfrctl1 |= ahd->seltime;
6246 }
6247
6248 ahd_outb(ahd, SXFRCTL0, DFON);
6249 ahd_outb(ahd, SXFRCTL1, sxfrctl1|ahd->seltime|ENSTIMER|ACTNEGEN);
6250 ahd_outb(ahd, SIMODE1, ENSELTIMO|ENSCSIRST|ENSCSIPERR);
6251
6252 /*
6253 * Now that termination is set, wait for up
6254 * to 500ms for our transceivers to settle. If
6255 * the adapter does not have a cable attached,
6256 * the transceivers may never settle, so don't
6257 * complain if we fail here.
6258 */
6259 for (wait = 10000;
6260 (ahd_inb(ahd, SBLKCTL) & (ENAB40|ENAB20)) == 0 && wait;
6261 wait--)
6262 ahd_delay(100);
6263
6264 /* Clear any false bus resets due to the transceivers settling */
6265 ahd_outb(ahd, CLRSINT1, CLRSCSIRSTI);
6266 ahd_outb(ahd, CLRINT, CLRSCSIINT);
6267
6268 /* Initialize mode specific S/G state. */
6269 for (i = 0; i < 2; i++) {
6270 ahd_set_modes(ahd, AHD_MODE_DFF0 + i, AHD_MODE_DFF0 + i);
6271 ahd_outb(ahd, LONGJMP_ADDR + 1, INVALID_ADDR);
6272 ahd_outb(ahd, SG_STATE, 0);
6273 ahd_outb(ahd, CLRSEQINTSRC, 0xFF);
6274 ahd_outb(ahd, SEQIMODE,
6275 ENSAVEPTRS|ENCFG4DATA|ENCFG4ISTAT
6276 |ENCFG4TSTAT|ENCFG4ICMD|ENCFG4TCMD);
6277 }
6278
6279 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
6280 ahd_outb(ahd, DSCOMMAND0, ahd_inb(ahd, DSCOMMAND0)|MPARCKEN|CACHETHEN);
6281 ahd_outb(ahd, DFF_THRSH, RD_DFTHRSH_75|WR_DFTHRSH_75);
6282 ahd_outb(ahd, SIMODE0, ENIOERR|ENOVERRUN);
6283 ahd_outb(ahd, SIMODE3, ENNTRAMPERR|ENOSRAMPERR);
6284 if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) {
6285 ahd_outb(ahd, OPTIONMODE, AUTOACKEN|AUTO_MSGOUT_DE);
6286 } else {
6287 ahd_outb(ahd, OPTIONMODE, AUTOACKEN|BUSFREEREV|AUTO_MSGOUT_DE);
6288 }
6289 ahd_outb(ahd, SCSCHKN, CURRFIFODEF|WIDERESEN|SHVALIDSTDIS);
6290 if ((ahd->chip & AHD_BUS_MASK) == AHD_PCIX)
6291 /*
6292 * Do not issue a target abort when a split completion
6293 * error occurs. Let our PCIX interrupt handler deal
6294 * with it instead. H2A4 Razor #625
6295 */
6296 ahd_outb(ahd, PCIXCTL, ahd_inb(ahd, PCIXCTL) | SPLTSTADIS);
6297
6298 if ((ahd->bugs & AHD_LQOOVERRUN_BUG) != 0)
6299 ahd_outb(ahd, LQOSCSCTL, LQONOCHKOVER);
6300
6301 /*
6302 * Tweak IOCELL settings.
6303 */
6304 if ((ahd->flags & AHD_HP_BOARD) != 0) {
6305 for (i = 0; i < NUMDSPS; i++) {
6306 ahd_outb(ahd, DSPSELECT, i);
6307 ahd_outb(ahd, WRTBIASCTL, WRTBIASCTL_HP_DEFAULT);
6308 }
6309 #ifdef AHD_DEBUG
6310 if ((ahd_debug & AHD_SHOW_MISC) != 0)
6311 printf("%s: WRTBIASCTL now 0x%x\n", ahd_name(ahd),
6312 WRTBIASCTL_HP_DEFAULT);
6313 #endif
6314 }
6315 ahd_setup_iocell_workaround(ahd);
6316
6317 /*
6318 * Enable LQI Manager interrupts.
6319 */
6320 ahd_outb(ahd, LQIMODE1, ENLQIPHASE_LQ|ENLQIPHASE_NLQ|ENLIQABORT
6321 | ENLQICRCI_LQ|ENLQICRCI_NLQ|ENLQIBADLQI
6322 | ENLQIOVERI_LQ|ENLQIOVERI_NLQ);
6323 ahd_outb(ahd, LQOMODE0, ENLQOATNLQ|ENLQOATNPKT|ENLQOTCRC);
6324 /*
6325 * An interrupt from LQOBUSFREE is made redundant by the
6326 * BUSFREE interrupt. We choose to have the sequencer catch
6327 * LQOPHCHGINPKT errors manually for the command phase at the
6328 * start of a packetized selection case.
6329 ahd_outb(ahd, LQOMODE1, ENLQOBUSFREE|ENLQOPHACHGINPKT);
6330 */
6331 ahd_outb(ahd, LQOMODE1, 0);
6332
6333 /*
6334 * Setup sequencer interrupt handlers.
6335 */
6336 ahd_outw(ahd, INTVEC1_ADDR, ahd_resolve_seqaddr(ahd, LABEL_seq_isr));
6337 ahd_outw(ahd, INTVEC2_ADDR, ahd_resolve_seqaddr(ahd, LABEL_timer_isr));
6338
6339 /*
6340 * Setup SCB Offset registers.
6341 */
6342 if ((ahd->bugs & AHD_PKT_LUN_BUG) != 0) {
6343 ahd_outb(ahd, LUNPTR, offsetof(struct hardware_scb,
6344 pkt_long_lun));
6345 } else {
6346 ahd_outb(ahd, LUNPTR, offsetof(struct hardware_scb, lun));
6347 }
6348 ahd_outb(ahd, CMDLENPTR, offsetof(struct hardware_scb, cdb_len));
6349 ahd_outb(ahd, ATTRPTR, offsetof(struct hardware_scb, task_attribute));
6350 ahd_outb(ahd, FLAGPTR, offsetof(struct hardware_scb, task_management));
6351 ahd_outb(ahd, CMDPTR, offsetof(struct hardware_scb,
6352 shared_data.idata.cdb));
6353 ahd_outb(ahd, QNEXTPTR,
6354 offsetof(struct hardware_scb, next_hscb_busaddr));
6355 ahd_outb(ahd, ABRTBITPTR, MK_MESSAGE_BIT_OFFSET);
6356 ahd_outb(ahd, ABRTBYTEPTR, offsetof(struct hardware_scb, control));
6357 if ((ahd->bugs & AHD_PKT_LUN_BUG) != 0) {
6358 ahd_outb(ahd, LUNLEN,
6359 sizeof(ahd->next_queued_hscb->pkt_long_lun) - 1);
6360 } else {
6361 ahd_outb(ahd, LUNLEN, LUNLEN_SINGLE_LEVEL_LUN);
6362 }
6363 ahd_outb(ahd, CDBLIMIT, SCB_CDB_LEN_PTR - 1);
6364 ahd_outb(ahd, MAXCMD, 0xFF);
6365 ahd_outb(ahd, SCBAUTOPTR,
6366 AUSCBPTR_EN | offsetof(struct hardware_scb, tag));
6367
6368 /* We haven't been enabled for target mode yet. */
6369 ahd_outb(ahd, MULTARGID, 0);
6370 ahd_outb(ahd, MULTARGID + 1, 0);
6371
6372 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
6373 /* Initialize the negotiation table. */
6374 if ((ahd->features & AHD_NEW_IOCELL_OPTS) == 0) {
6375 /*
6376 * Clear the spare bytes in the neg table to avoid
6377 * spurious parity errors.
6378 */
6379 for (target = 0; target < AHD_NUM_TARGETS; target++) {
6380 ahd_outb(ahd, NEGOADDR, target);
6381 ahd_outb(ahd, ANNEXCOL, AHD_ANNEXCOL_PER_DEV0);
6382 for (i = 0; i < AHD_NUM_PER_DEV_ANNEXCOLS; i++)
6383 ahd_outb(ahd, ANNEXDAT, 0);
6384 }
6385 }
6386
6387 for (target = 0; target < AHD_NUM_TARGETS; target++) {
6388 struct ahd_devinfo devinfo;
6389 struct ahd_initiator_tinfo *tinfo;
6390 struct ahd_tmode_tstate *tstate;
6391
6392 tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
6393 target, &tstate);
6394 ahd_compile_devinfo(&devinfo, ahd->our_id,
6395 target, CAM_LUN_WILDCARD,
6396 'A', ROLE_INITIATOR);
6397 ahd_update_neg_table(ahd, &devinfo, &tinfo->curr);
6398 }
6399
6400 ahd_outb(ahd, CLRSINT3, NTRAMPERR|OSRAMPERR);
6401 ahd_outb(ahd, CLRINT, CLRSCSIINT);
6402
6403 #if NEEDS_MORE_TESTING
6404 /*
6405 * Always enable abort on incoming L_Qs if this feature is
6406 * supported. We use this to catch invalid SCB references.
6407 */
6408 if ((ahd->bugs & AHD_ABORT_LQI_BUG) == 0)
6409 ahd_outb(ahd, LQCTL1, ABORTPENDING);
6410 else
6411 #endif
6412 ahd_outb(ahd, LQCTL1, 0);
6413
6414 /* All of our queues are empty */
6415 ahd->qoutfifonext = 0;
6416 ahd->qoutfifonext_valid_tag = QOUTFIFO_ENTRY_VALID_LE;
6417 ahd_outb(ahd, QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID >> 8);
6418 for (i = 0; i < AHD_QOUT_SIZE; i++)
6419 ahd->qoutfifo[i] = 0;
6420 ahd_sync_qoutfifo(ahd, BUS_DMASYNC_PREREAD);
6421
6422 ahd->qinfifonext = 0;
6423 for (i = 0; i < AHD_QIN_SIZE; i++)
6424 ahd->qinfifo[i] = SCB_LIST_NULL;
6425
6426 if ((ahd->features & AHD_TARGETMODE) != 0) {
6427 /* All target command blocks start out invalid. */
6428 for (i = 0; i < AHD_TMODE_CMDS; i++)
6429 ahd->targetcmds[i].cmd_valid = 0;
6430 ahd_sync_tqinfifo(ahd, BUS_DMASYNC_PREREAD);
6431 ahd->tqinfifonext = 1;
6432 ahd_outb(ahd, KERNEL_TQINPOS, ahd->tqinfifonext - 1);
6433 ahd_outb(ahd, TQINPOS, ahd->tqinfifonext);
6434 }
6435
6436 /* Initialize Scratch Ram. */
6437 ahd_outb(ahd, SEQ_FLAGS, 0);
6438 ahd_outb(ahd, SEQ_FLAGS2, 0);
6439
6440 /* We don't have any waiting selections */
6441 ahd_outw(ahd, WAITING_TID_HEAD, SCB_LIST_NULL);
6442 ahd_outw(ahd, WAITING_TID_TAIL, SCB_LIST_NULL);
6443 for (i = 0; i < AHD_NUM_TARGETS; i++) {
6444 ahd_outw(ahd, WAITING_SCB_TAILS + (2 * i), SCB_LIST_NULL);
6445 }
6446
6447 /*
6448 * Nobody is waiting to be DMAed into the QOUTFIFO.
6449 */
6450 ahd_outw(ahd, COMPLETE_SCB_HEAD, SCB_LIST_NULL);
6451 ahd_outw(ahd, COMPLETE_SCB_DMAINPROG_HEAD, SCB_LIST_NULL);
6452 ahd_outw(ahd, COMPLETE_DMA_SCB_HEAD, SCB_LIST_NULL);
6453
6454 /*
6455 * The Freeze Count is 0.
6456 */
6457 ahd_outw(ahd, QFREEZE_COUNT, 0);
6458
6459 /*
6460 * Tell the sequencer where it can find our arrays in memory.
6461 */
6462 busaddr = ahd->shared_data_map.physaddr;
6463 ahd_outb(ahd, SHARED_DATA_ADDR, busaddr & 0xFF);
6464 ahd_outb(ahd, SHARED_DATA_ADDR + 1, (busaddr >> 8) & 0xFF);
6465 ahd_outb(ahd, SHARED_DATA_ADDR + 2, (busaddr >> 16) & 0xFF);
6466 ahd_outb(ahd, SHARED_DATA_ADDR + 3, (busaddr >> 24) & 0xFF);
6467 ahd_outb(ahd, QOUTFIFO_NEXT_ADDR, busaddr & 0xFF);
6468 ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 1, (busaddr >> 8) & 0xFF);
6469 ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 2, (busaddr >> 16) & 0xFF);
6470 ahd_outb(ahd, QOUTFIFO_NEXT_ADDR + 3, (busaddr >> 24) & 0xFF);
6471 /*
6472 * Setup the allowed SCSI Sequences based on operational mode.
6473 * If we are a target, we'll enable select in operations once
6474 * we've had a lun enabled.
6475 */
6476 scsiseq_template = ENAUTOATNP;
6477 if ((ahd->flags & AHD_INITIATORROLE) != 0)
6478 scsiseq_template |= ENRSELI;
6479 ahd_outb(ahd, SCSISEQ_TEMPLATE, scsiseq_template);
6480
6481 /* There are no busy SCBs yet. */
6482 for (target = 0; target < AHD_NUM_TARGETS; target++) {
6483 int lun;
6484
6485 for (lun = 0; lun < AHD_NUM_LUNS_NONPKT; lun++)
6486 ahd_unbusy_tcl(ahd, BUILD_TCL_RAW(target, 'A', lun));
6487 }
6488
6489 /*
6490 * Initialize the group code to command length table.
6491 * Vendor Unique codes are set to 0 so we only capture
6492 * the first byte of the cdb. These can be overridden
6493 * when target mode is enabled.
6494 */
6495 ahd_outb(ahd, CMDSIZE_TABLE, 5);
6496 ahd_outb(ahd, CMDSIZE_TABLE + 1, 9);
6497 ahd_outb(ahd, CMDSIZE_TABLE + 2, 9);
6498 ahd_outb(ahd, CMDSIZE_TABLE + 3, 0);
6499 ahd_outb(ahd, CMDSIZE_TABLE + 4, 15);
6500 ahd_outb(ahd, CMDSIZE_TABLE + 5, 11);
6501 ahd_outb(ahd, CMDSIZE_TABLE + 6, 0);
6502 ahd_outb(ahd, CMDSIZE_TABLE + 7, 0);
6503
6504 /* Tell the sequencer of our initial queue positions */
6505 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
6506 ahd_outb(ahd, QOFF_CTLSTA, SCB_QSIZE_512);
6507 ahd->qinfifonext = 0;
6508 ahd_set_hnscb_qoff(ahd, ahd->qinfifonext);
6509 ahd_set_hescb_qoff(ahd, 0);
6510 ahd_set_snscb_qoff(ahd, 0);
6511 ahd_set_sescb_qoff(ahd, 0);
6512 ahd_set_sdscb_qoff(ahd, 0);
6513
6514 /*
6515 * Tell the sequencer which SCB will be the next one it receives.
6516 */
6517 busaddr = ahd_le32toh(ahd->next_queued_hscb->hscb_busaddr);
6518 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
6519 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
6520 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
6521 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
6522
6523 /*
6524 * Default to coalescing disabled.
6525 */
6526 ahd_outw(ahd, INT_COALESCING_CMDCOUNT, 0);
6527 ahd_outw(ahd, CMDS_PENDING, 0);
6528 ahd_update_coalescing_values(ahd, ahd->int_coalescing_timer,
6529 ahd->int_coalescing_maxcmds,
6530 ahd->int_coalescing_mincmds);
6531 ahd_enable_coalescing(ahd, FALSE);
6532
6533 ahd_loadseq(ahd);
6534 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
6535 }
6536
6537 /*
6538 * Setup default device and controller settings.
6539 * This should only be called if our probe has
6540 * determined that no configuration data is available.
6541 */
6542 int
6543 ahd_default_config(struct ahd_softc *ahd)
6544 {
6545 int targ;
6546
6547 ahd->our_id = 7;
6548
6549 /*
6550 * Allocate a tstate to house information for our
6551 * initiator presence on the bus as well as the user
6552 * data for any target mode initiator.
6553 */
6554 if (ahd_alloc_tstate(ahd, ahd->our_id, 'A') == NULL) {
6555 printf("%s: unable to allocate ahd_tmode_tstate. "
6556 "Failing attach\n", ahd_name(ahd));
6557 return (ENOMEM);
6558 }
6559
6560 for (targ = 0; targ < AHD_NUM_TARGETS; targ++) {
6561 struct ahd_devinfo devinfo;
6562 struct ahd_initiator_tinfo *tinfo;
6563 struct ahd_tmode_tstate *tstate;
6564 uint16_t target_mask;
6565
6566 tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
6567 targ, &tstate);
6568 /*
6569 * We support SPC2 and SPI4.
6570 */
6571 tinfo->user.protocol_version = 4;
6572 tinfo->user.transport_version = 4;
6573
6574 target_mask = 0x01 << targ;
6575 ahd->user_discenable |= target_mask;
6576 tstate->discenable |= target_mask;
6577 ahd->user_tagenable |= target_mask;
6578 #ifdef AHD_FORCE_160
6579 tinfo->user.period = AHD_SYNCRATE_DT;
6580 #else
6581 tinfo->user.period = AHD_SYNCRATE_160;
6582 #endif
6583 tinfo->user.offset= MAX_OFFSET;
6584 tinfo->user.ppr_options = MSG_EXT_PPR_RDSTRM
6585 | MSG_EXT_PPR_WRFLOW
6586 | MSG_EXT_PPR_HOLDMCS
6587 | MSG_EXT_PPR_IU_REQ
6588 | MSG_EXT_PPR_QAS_REQ
6589 | MSG_EXT_PPR_DT_REQ;
6590 if ((ahd->features & AHD_RTI) != 0)
6591 tinfo->user.ppr_options |= MSG_EXT_PPR_RTI;
6592
6593 tinfo->user.width = MSG_EXT_WDTR_BUS_16_BIT;
6594
6595 /*
6596 * Start out Async/Narrow/Untagged and with
6597 * conservative protocol support.
6598 */
6599 tinfo->goal.protocol_version = 2;
6600 tinfo->goal.transport_version = 2;
6601 tinfo->curr.protocol_version = 2;
6602 tinfo->curr.transport_version = 2;
6603 ahd_compile_devinfo(&devinfo, ahd->our_id,
6604 targ, CAM_LUN_WILDCARD,
6605 'A', ROLE_INITIATOR);
6606 tstate->tagenable &= ~target_mask;
6607 ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
6608 AHD_TRANS_CUR|AHD_TRANS_GOAL, /*paused*/TRUE);
6609 ahd_set_syncrate(ahd, &devinfo, /*period*/0, /*offset*/0,
6610 /*ppr_options*/0, AHD_TRANS_CUR|AHD_TRANS_GOAL,
6611 /*paused*/TRUE);
6612 }
6613 return (0);
6614 }
6615
6616 /*
6617 * Parse device configuration information.
6618 */
6619 int
6620 ahd_parse_cfgdata(struct ahd_softc *ahd, struct seeprom_config *sc)
6621 {
6622 int targ;
6623 int max_targ;
6624
6625 max_targ = sc->max_targets & CFMAXTARG;
6626 ahd->our_id = sc->brtime_id & CFSCSIID;
6627
6628 /*
6629 * Allocate a tstate to house information for our
6630 * initiator presence on the bus as well as the user
6631 * data for any target mode initiator.
6632 */
6633 if (ahd_alloc_tstate(ahd, ahd->our_id, 'A') == NULL) {
6634 printf("%s: unable to allocate ahd_tmode_tstate. "
6635 "Failing attach\n", ahd_name(ahd));
6636 return (ENOMEM);
6637 }
6638
6639 for (targ = 0; targ < max_targ; targ++) {
6640 struct ahd_devinfo devinfo;
6641 struct ahd_initiator_tinfo *tinfo;
6642 struct ahd_transinfo *user_tinfo;
6643 struct ahd_tmode_tstate *tstate;
6644 uint16_t target_mask;
6645
6646 tinfo = ahd_fetch_transinfo(ahd, 'A', ahd->our_id,
6647 targ, &tstate);
6648 user_tinfo = &tinfo->user;
6649
6650 /*
6651 * We support SPC2 and SPI4.
6652 */
6653 tinfo->user.protocol_version = 4;
6654 tinfo->user.transport_version = 4;
6655
6656 target_mask = 0x01 << targ;
6657 ahd->user_discenable &= ~target_mask;
6658 tstate->discenable &= ~target_mask;
6659 ahd->user_tagenable &= ~target_mask;
6660 if (sc->device_flags[targ] & CFDISC) {
6661 tstate->discenable |= target_mask;
6662 ahd->user_discenable |= target_mask;
6663 ahd->user_tagenable |= target_mask;
6664 } else {
6665 /*
6666 * Cannot be packetized without disconnection.
6667 */
6668 sc->device_flags[targ] &= ~CFPACKETIZED;
6669 }
6670
6671 user_tinfo->ppr_options = 0;
6672 user_tinfo->period = (sc->device_flags[targ] & CFXFER);
6673 if (user_tinfo->period < CFXFER_ASYNC) {
6674 if (user_tinfo->period <= AHD_PERIOD_10MHz)
6675 user_tinfo->ppr_options |= MSG_EXT_PPR_DT_REQ;
6676 user_tinfo->offset = MAX_OFFSET;
6677 } else {
6678 user_tinfo->offset = 0;
6679 user_tinfo->period = AHD_ASYNC_XFER_PERIOD;
6680 }
6681 #ifdef AHD_FORCE_160
6682 if (user_tinfo->period <= AHD_SYNCRATE_160)
6683 user_tinfo->period = AHD_SYNCRATE_DT;
6684 #endif
6685
6686 if ((sc->device_flags[targ] & CFPACKETIZED) != 0) {
6687 user_tinfo->ppr_options |= MSG_EXT_PPR_RDSTRM
6688 | MSG_EXT_PPR_WRFLOW
6689 | MSG_EXT_PPR_HOLDMCS
6690 | MSG_EXT_PPR_IU_REQ;
6691 if ((ahd->features & AHD_RTI) != 0)
6692 user_tinfo->ppr_options |= MSG_EXT_PPR_RTI;
6693 }
6694
6695 if ((sc->device_flags[targ] & CFQAS) != 0)
6696 user_tinfo->ppr_options |= MSG_EXT_PPR_QAS_REQ;
6697
6698 if ((sc->device_flags[targ] & CFWIDEB) != 0)
6699 user_tinfo->width = MSG_EXT_WDTR_BUS_16_BIT;
6700 else
6701 user_tinfo->width = MSG_EXT_WDTR_BUS_8_BIT;
6702 #ifdef AHD_DEBUG
6703 if ((ahd_debug & AHD_SHOW_MISC) != 0)
6704 printf("(%d): %x:%x:%x:%x\n", targ, user_tinfo->width,
6705 user_tinfo->period, user_tinfo->offset,
6706 user_tinfo->ppr_options);
6707 #endif
6708 /*
6709 * Start out Async/Narrow/Untagged and with
6710 * conservative protocol support.
6711 */
6712 tstate->tagenable &= ~target_mask;
6713 tinfo->goal.protocol_version = 2;
6714 tinfo->goal.transport_version = 2;
6715 tinfo->curr.protocol_version = 2;
6716 tinfo->curr.transport_version = 2;
6717 ahd_compile_devinfo(&devinfo, ahd->our_id,
6718 targ, CAM_LUN_WILDCARD,
6719 'A', ROLE_INITIATOR);
6720 ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
6721 AHD_TRANS_CUR|AHD_TRANS_GOAL, /*paused*/TRUE);
6722 ahd_set_syncrate(ahd, &devinfo, /*period*/0, /*offset*/0,
6723 /*ppr_options*/0, AHD_TRANS_CUR|AHD_TRANS_GOAL,
6724 /*paused*/TRUE);
6725 }
6726
6727 ahd->flags &= ~AHD_SPCHK_ENB_A;
6728 if (sc->bios_control & CFSPARITY)
6729 ahd->flags |= AHD_SPCHK_ENB_A;
6730
6731 ahd->flags &= ~AHD_RESET_BUS_A;
6732 if (sc->bios_control & CFRESETB)
6733 ahd->flags |= AHD_RESET_BUS_A;
6734
6735 ahd->flags &= ~AHD_EXTENDED_TRANS_A;
6736 if (sc->bios_control & CFEXTEND)
6737 ahd->flags |= AHD_EXTENDED_TRANS_A;
6738
6739 ahd->flags &= ~AHD_BIOS_ENABLED;
6740 if ((sc->bios_control & CFBIOSSTATE) == CFBS_ENABLED)
6741 ahd->flags |= AHD_BIOS_ENABLED;
6742
6743 ahd->flags &= ~AHD_STPWLEVEL_A;
6744 if ((sc->adapter_control & CFSTPWLEVEL) != 0)
6745 ahd->flags |= AHD_STPWLEVEL_A;
6746
6747 return (0);
6748 }
6749
6750 /*
6751 * Parse device configuration information.
6752 */
6753 int
6754 ahd_parse_vpddata(struct ahd_softc *ahd, struct vpd_config *vpd)
6755 {
6756 int error;
6757
6758 error = ahd_verify_vpd_cksum(vpd);
6759 if (error == 0)
6760 return (EINVAL);
6761 if ((vpd->bios_flags & VPDBOOTHOST) != 0)
6762 ahd->flags |= AHD_BOOT_CHANNEL;
6763 return (0);
6764 }
6765
6766 void
6767 ahd_intr_enable(struct ahd_softc *ahd, int enable)
6768 {
6769 u_int hcntrl;
6770
6771 hcntrl = ahd_inb(ahd, HCNTRL);
6772 hcntrl &= ~INTEN;
6773 ahd->pause &= ~INTEN;
6774 ahd->unpause &= ~INTEN;
6775 if (enable) {
6776 hcntrl |= INTEN;
6777 ahd->pause |= INTEN;
6778 ahd->unpause |= INTEN;
6779 }
6780 ahd_outb(ahd, HCNTRL, hcntrl);
6781 }
6782
6783 void
6784 ahd_update_coalescing_values(struct ahd_softc *ahd, u_int timer, u_int maxcmds,
6785 u_int mincmds)
6786 {
6787 if (timer > AHD_TIMER_MAX_US)
6788 timer = AHD_TIMER_MAX_US;
6789 ahd->int_coalescing_timer = timer;
6790
6791 if (maxcmds > AHD_INT_COALESCING_MAXCMDS_MAX)
6792 maxcmds = AHD_INT_COALESCING_MAXCMDS_MAX;
6793 if (mincmds > AHD_INT_COALESCING_MINCMDS_MAX)
6794 mincmds = AHD_INT_COALESCING_MINCMDS_MAX;
6795 ahd->int_coalescing_maxcmds = maxcmds;
6796 ahd_outw(ahd, INT_COALESCING_TIMER, timer / AHD_TIMER_US_PER_TICK);
6797 ahd_outb(ahd, INT_COALESCING_MAXCMDS, -maxcmds);
6798 ahd_outb(ahd, INT_COALESCING_MINCMDS, -mincmds);
6799 }
6800
6801 void
6802 ahd_enable_coalescing(struct ahd_softc *ahd, int enable)
6803 {
6804
6805 ahd->hs_mailbox &= ~ENINT_COALESCE;
6806 if (enable)
6807 ahd->hs_mailbox |= ENINT_COALESCE;
6808 ahd_outb(ahd, HS_MAILBOX, ahd->hs_mailbox);
6809 ahd_flush_device_writes(ahd);
6810 ahd_run_qoutfifo(ahd);
6811 }
6812
6813 /*
6814 * Ensure that the card is paused in a location
6815 * outside of all critical sections and that all
6816 * pending work is completed prior to returning.
6817 * This routine should only be called from outside
6818 * an interrupt context.
6819 */
6820 void
6821 ahd_pause_and_flushwork(struct ahd_softc *ahd)
6822 {
6823 u_int intstat;
6824 u_int maxloops;
6825 u_int qfreeze_cnt;
6826
6827 maxloops = 1000;
6828 ahd->flags |= AHD_ALL_INTERRUPTS;
6829 ahd_pause(ahd);
6830 /*
6831 * Increment the QFreeze Count so that the sequencer
6832 * will not start new selections. We do this only
6833 * until we are safely paused without further selections
6834 * pending.
6835 */
6836 ahd_outw(ahd, QFREEZE_COUNT, ahd_inw(ahd, QFREEZE_COUNT) + 1);
6837 ahd_outb(ahd, SEQ_FLAGS2, ahd_inb(ahd, SEQ_FLAGS2) | SELECTOUT_QFROZEN);
6838 do {
6839 struct scb *waiting_scb;
6840
6841 ahd_unpause(ahd);
6842 ahd_intr(ahd);
6843 ahd_pause(ahd);
6844 ahd_clear_critical_section(ahd);
6845 intstat = ahd_inb(ahd, INTSTAT);
6846 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
6847 if ((ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) == 0)
6848 ahd_outb(ahd, SCSISEQ0,
6849 ahd_inb(ahd, SCSISEQ0) & ~ENSELO);
6850 /*
6851 * In the non-packetized case, the sequencer (for Rev A),
6852 * relies on ENSELO remaining set after SELDO. The hardware
6853 * auto-clears ENSELO in the packetized case.
6854 */
6855 waiting_scb = ahd_lookup_scb(ahd,
6856 ahd_inw(ahd, WAITING_TID_HEAD));
6857 if (waiting_scb != NULL
6858 && (waiting_scb->flags & SCB_PACKETIZED) == 0
6859 && (ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) != 0)
6860 ahd_outb(ahd, SCSISEQ0,
6861 ahd_inb(ahd, SCSISEQ0) | ENSELO);
6862 } while (--maxloops
6863 && (intstat != 0xFF || (ahd->features & AHD_REMOVABLE) == 0)
6864 && ((intstat & INT_PEND) != 0
6865 || (ahd_inb(ahd, SCSISEQ0) & ENSELO) != 0
6866 || (ahd_inb(ahd, SSTAT0) & (SELDO|SELINGO)) != 0));
6867 if (maxloops == 0) {
6868 printf("Infinite interrupt loop, INTSTAT = %x",
6869 ahd_inb(ahd, INTSTAT));
6870 }
6871 qfreeze_cnt = ahd_inw(ahd, QFREEZE_COUNT);
6872 if (qfreeze_cnt == 0) {
6873 printf("%s: ahd_pause_and_flushwork with 0 qfreeze count!\n",
6874 ahd_name(ahd));
6875 } else {
6876 qfreeze_cnt--;
6877 }
6878 ahd_outw(ahd, QFREEZE_COUNT, qfreeze_cnt);
6879 if (qfreeze_cnt == 0)
6880 ahd_outb(ahd, SEQ_FLAGS2,
6881 ahd_inb(ahd, SEQ_FLAGS2) & ~SELECTOUT_QFROZEN);
6882
6883 ahd_flush_qoutfifo(ahd);
6884
6885 ahd_platform_flushwork(ahd);
6886 ahd->flags &= ~AHD_ALL_INTERRUPTS;
6887 }
6888
6889 int
6890 ahd_suspend(struct ahd_softc *ahd)
6891 {
6892
6893 ahd_pause_and_flushwork(ahd);
6894
6895 if (LIST_FIRST(&ahd->pending_scbs) != NULL) {
6896 ahd_unpause(ahd);
6897 return (EBUSY);
6898 }
6899 ahd_shutdown(ahd);
6900 return (0);
6901 }
6902
6903 int
6904 ahd_resume(struct ahd_softc *ahd)
6905 {
6906
6907 ahd_reset(ahd, /*reinit*/TRUE);
6908 ahd_intr_enable(ahd, TRUE);
6909 ahd_restart(ahd);
6910 return (0);
6911 }
6912
6913 /************************** Busy Target Table *********************************/
6914 /*
6915 * Set SCBPTR to the SCB that contains the busy
6916 * table entry for TCL. Return the offset into
6917 * the SCB that contains the entry for TCL.
6918 * saved_scbid is dereferenced and set to the
6919 * scbid that should be restored once manipualtion
6920 * of the TCL entry is complete.
6921 */
6922 static inline u_int
6923 ahd_index_busy_tcl(struct ahd_softc *ahd, u_int *saved_scbid, u_int tcl)
6924 {
6925 /*
6926 * Index to the SCB that contains the busy entry.
6927 */
6928 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
6929 *saved_scbid = ahd_get_scbptr(ahd);
6930 ahd_set_scbptr(ahd, TCL_LUN(tcl)
6931 | ((TCL_TARGET_OFFSET(tcl) & 0xC) << 4));
6932
6933 /*
6934 * And now calculate the SCB offset to the entry.
6935 * Each entry is 2 bytes wide, hence the
6936 * multiplication by 2.
6937 */
6938 return (((TCL_TARGET_OFFSET(tcl) & 0x3) << 1) + SCB_DISCONNECTED_LISTS);
6939 }
6940
6941 /*
6942 * Return the untagged transaction id for a given target/channel lun.
6943 */
6944 u_int
6945 ahd_find_busy_tcl(struct ahd_softc *ahd, u_int tcl)
6946 {
6947 u_int scbid;
6948 u_int scb_offset;
6949 u_int saved_scbptr;
6950
6951 scb_offset = ahd_index_busy_tcl(ahd, &saved_scbptr, tcl);
6952 scbid = ahd_inw_scbram(ahd, scb_offset);
6953 ahd_set_scbptr(ahd, saved_scbptr);
6954 return (scbid);
6955 }
6956
6957 void
6958 ahd_busy_tcl(struct ahd_softc *ahd, u_int tcl, u_int scbid)
6959 {
6960 u_int scb_offset;
6961 u_int saved_scbptr;
6962
6963 scb_offset = ahd_index_busy_tcl(ahd, &saved_scbptr, tcl);
6964 ahd_outw(ahd, scb_offset, scbid);
6965 ahd_set_scbptr(ahd, saved_scbptr);
6966 }
6967
6968 /************************** SCB and SCB queue management **********************/
6969 int
6970 ahd_match_scb(struct ahd_softc *ahd, struct scb *scb, int target,
6971 char channel, int lun, u_int tag, role_t role)
6972 {
6973 int targ = SCB_GET_TARGET(ahd, scb);
6974 char chan = SCB_GET_CHANNEL(ahd, scb);
6975 int slun = SCB_GET_LUN(scb);
6976 int match;
6977
6978 match = ((chan == channel) || (channel == ALL_CHANNELS));
6979 if (match != 0)
6980 match = ((targ == target) || (target == CAM_TARGET_WILDCARD));
6981 if (match != 0)
6982 match = ((lun == slun) || (lun == CAM_LUN_WILDCARD));
6983 if (match != 0) {
6984 #if AHD_TARGET_MODE
6985 int group;
6986
6987 group = XPT_FC_GROUP(scb->io_ctx->ccb_h.func_code);
6988 if (role == ROLE_INITIATOR) {
6989 match = (group != XPT_FC_GROUP_TMODE)
6990 && ((tag == SCB_GET_TAG(scb))
6991 || (tag == SCB_LIST_NULL));
6992 } else if (role == ROLE_TARGET) {
6993 match = (group == XPT_FC_GROUP_TMODE)
6994 && ((tag == scb->io_ctx->csio.tag_id)
6995 || (tag == SCB_LIST_NULL));
6996 }
6997 #else /* !AHD_TARGET_MODE */
6998 match = ((tag == SCB_GET_TAG(scb)) || (tag == SCB_LIST_NULL));
6999 #endif /* AHD_TARGET_MODE */
7000 }
7001
7002 return match;
7003 }
7004
7005 void
7006 ahd_freeze_devq(struct ahd_softc *ahd, struct scb *scb)
7007 {
7008 int target;
7009 char channel;
7010 int lun;
7011
7012 target = SCB_GET_TARGET(ahd, scb);
7013 lun = SCB_GET_LUN(scb);
7014 channel = SCB_GET_CHANNEL(ahd, scb);
7015
7016 ahd_search_qinfifo(ahd, target, channel, lun,
7017 /*tag*/SCB_LIST_NULL, ROLE_UNKNOWN,
7018 CAM_REQUEUE_REQ, SEARCH_COMPLETE);
7019
7020 ahd_platform_freeze_devq(ahd, scb);
7021 }
7022
7023 void
7024 ahd_qinfifo_requeue_tail(struct ahd_softc *ahd, struct scb *scb)
7025 {
7026 struct scb *prev_scb;
7027 ahd_mode_state saved_modes;
7028
7029 saved_modes = ahd_save_modes(ahd);
7030 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
7031 prev_scb = NULL;
7032 if (ahd_qinfifo_count(ahd) != 0) {
7033 u_int prev_tag;
7034 u_int prev_pos;
7035
7036 prev_pos = AHD_QIN_WRAP(ahd->qinfifonext - 1);
7037 prev_tag = ahd->qinfifo[prev_pos];
7038 prev_scb = ahd_lookup_scb(ahd, prev_tag);
7039 }
7040 ahd_qinfifo_requeue(ahd, prev_scb, scb);
7041 ahd_set_hnscb_qoff(ahd, ahd->qinfifonext);
7042 ahd_restore_modes(ahd, saved_modes);
7043 }
7044
7045 static void
7046 ahd_qinfifo_requeue(struct ahd_softc *ahd, struct scb *prev_scb,
7047 struct scb *scb)
7048 {
7049 if (prev_scb == NULL) {
7050 uint32_t busaddr;
7051
7052 busaddr = ahd_le32toh(scb->hscb->hscb_busaddr);
7053 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
7054 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
7055 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
7056 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
7057 } else {
7058 prev_scb->hscb->next_hscb_busaddr = scb->hscb->hscb_busaddr;
7059 ahd_sync_scb(ahd, prev_scb,
7060 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7061 }
7062 ahd->qinfifo[AHD_QIN_WRAP(ahd->qinfifonext)] = SCB_GET_TAG(scb);
7063 ahd->qinfifonext++;
7064 scb->hscb->next_hscb_busaddr = ahd->next_queued_hscb->hscb_busaddr;
7065 ahd_sync_scb(ahd, scb, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
7066 }
7067
7068 static int
7069 ahd_qinfifo_count(struct ahd_softc *ahd)
7070 {
7071 u_int qinpos;
7072 u_int wrap_qinpos;
7073 u_int wrap_qinfifonext;
7074
7075 AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
7076 qinpos = ahd_get_snscb_qoff(ahd);
7077 wrap_qinpos = AHD_QIN_WRAP(qinpos);
7078 wrap_qinfifonext = AHD_QIN_WRAP(ahd->qinfifonext);
7079 if (wrap_qinfifonext >= wrap_qinpos)
7080 return (wrap_qinfifonext - wrap_qinpos);
7081 else
7082 return (wrap_qinfifonext
7083 + NUM_ELEMENTS(ahd->qinfifo) - wrap_qinpos);
7084 }
7085
7086 void
7087 ahd_reset_cmds_pending(struct ahd_softc *ahd)
7088 {
7089 struct scb *scb;
7090 ahd_mode_state saved_modes;
7091 u_int pending_cmds;
7092
7093 saved_modes = ahd_save_modes(ahd);
7094 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
7095
7096 /*
7097 * Don't count any commands as outstanding that the
7098 * sequencer has already marked for completion.
7099 */
7100 ahd_flush_qoutfifo(ahd);
7101
7102 pending_cmds = 0;
7103 LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
7104 pending_cmds++;
7105 }
7106 ahd_outw(ahd, CMDS_PENDING, pending_cmds - ahd_qinfifo_count(ahd));
7107 ahd_restore_modes(ahd, saved_modes);
7108 ahd->flags &= ~AHD_UPDATE_PEND_CMDS;
7109 }
7110
7111 int
7112 ahd_search_qinfifo(struct ahd_softc *ahd, int target, char channel,
7113 int lun, u_int tag, role_t role, uint32_t status,
7114 ahd_search_action action)
7115 {
7116 struct scb *scb;
7117 struct scb *prev_scb;
7118 ahd_mode_state saved_modes;
7119 u_int qinstart;
7120 u_int qinpos;
7121 u_int qintail;
7122 u_int tid_next;
7123 u_int tid_prev;
7124 u_int scbid;
7125 u_int savedscbptr;
7126 uint32_t busaddr;
7127 int found;
7128 int targets;
7129 int pending_cmds;
7130 int qincount;
7131
7132 /* Must be in CCHAN mode */
7133 saved_modes = ahd_save_modes(ahd);
7134 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
7135
7136 /*
7137 * Halt any pending SCB DMA. The sequencer will reinitiate
7138 * this DMA if the qinfifo is not empty once we unpause.
7139 */
7140 if ((ahd_inb(ahd, CCSCBCTL) & (CCARREN|CCSCBEN|CCSCBDIR))
7141 == (CCARREN|CCSCBEN|CCSCBDIR)) {
7142 ahd_outb(ahd, CCSCBCTL,
7143 ahd_inb(ahd, CCSCBCTL) & ~(CCARREN|CCSCBEN));
7144 while ((ahd_inb(ahd, CCSCBCTL) & (CCARREN|CCSCBEN)) != 0)
7145 ;
7146 }
7147 /* Determine sequencer's position in the qinfifo. */
7148 qintail = AHD_QIN_WRAP(ahd->qinfifonext);
7149 qinstart = ahd_get_snscb_qoff(ahd);
7150 qinpos = AHD_QIN_WRAP(qinstart);
7151 found = 0;
7152 prev_scb = NULL;
7153
7154 pending_cmds = 0;
7155 LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
7156 pending_cmds++;
7157 }
7158 qincount = ahd_qinfifo_count(ahd);
7159
7160 if (action == SEARCH_PRINT) {
7161 printf("qinstart = 0x%x qinfifonext = 0x%x\n",
7162 qinstart, ahd->qinfifonext);
7163 }
7164
7165 /*
7166 * Start with an empty queue. Entries that are not chosen
7167 * for removal will be re-added to the queue as we go.
7168 */
7169 ahd->qinfifonext = qinstart;
7170 busaddr = ahd_le32toh(ahd->next_queued_hscb->hscb_busaddr);
7171 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 0, busaddr & 0xFF);
7172 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 1, (busaddr >> 8) & 0xFF);
7173 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 2, (busaddr >> 16) & 0xFF);
7174 ahd_outb(ahd, NEXT_QUEUED_SCB_ADDR + 3, (busaddr >> 24) & 0xFF);
7175
7176 while (qinpos != qintail) {
7177 scb = ahd_lookup_scb(ahd, ahd->qinfifo[qinpos]);
7178 if (scb == NULL) {
7179 panic("Loop 1\n");
7180 }
7181
7182 if (ahd_match_scb(ahd, scb, target, channel, lun, tag, role)) {
7183 /*
7184 * We found an scb that needs to be acted on.
7185 */
7186 found++;
7187 switch (action) {
7188 case SEARCH_COMPLETE:
7189 {
7190 cam_status ostat;
7191 cam_status cstat;
7192
7193 ostat = ahd_get_scsi_status(scb);
7194 if (ostat == CAM_REQ_INPROG)
7195 ahd_set_scsi_status(scb, status);
7196 cstat = ahd_get_transaction_status(scb);
7197 if (cstat != CAM_REQ_CMP)
7198 ahd_freeze_scb(scb);
7199 if ((scb->flags & SCB_ACTIVE) == 0)
7200 printf("Inactive SCB in qinfifo\n");
7201 if (scb->xs->error != CAM_REQ_CMP)
7202 printf("SEARCH_COMPLETE(0x%x):"
7203 " ostat 0x%x, cstat 0x%x, "
7204 "xs_error 0x%x\n",
7205 SCB_GET_TAG(scb), ostat, cstat,
7206 scb->xs->error);
7207 ahd_done(ahd, scb);
7208
7209 /* FALLTHROUGH */
7210 }
7211 case SEARCH_REMOVE:
7212 break;
7213 case SEARCH_PRINT:
7214 printf(" 0x%x", ahd->qinfifo[qinpos]);
7215 /* FALLTHROUGH */
7216 case SEARCH_COUNT:
7217 ahd_qinfifo_requeue(ahd, prev_scb, scb);
7218 prev_scb = scb;
7219 break;
7220 }
7221 } else {
7222 ahd_qinfifo_requeue(ahd, prev_scb, scb);
7223 prev_scb = scb;
7224 }
7225 qinpos = AHD_QIN_WRAP(qinpos+1);
7226 }
7227
7228 ahd_set_hnscb_qoff(ahd, ahd->qinfifonext);
7229
7230 if (action == SEARCH_PRINT)
7231 printf("\nWAITING_TID_QUEUES:\n");
7232
7233 /*
7234 * Search waiting for selection lists. We traverse the
7235 * list of "their ids" waiting for selection and, if
7236 * appropriate, traverse the SCBs of each "their id"
7237 * looking for matches.
7238 */
7239 savedscbptr = ahd_get_scbptr(ahd);
7240 tid_next = ahd_inw(ahd, WAITING_TID_HEAD);
7241 tid_prev = SCB_LIST_NULL;
7242 targets = 0;
7243 for (scbid = tid_next; !SCBID_IS_NULL(scbid); scbid = tid_next) {
7244 u_int tid_head;
7245
7246 /*
7247 * We limit based on the number of SCBs since
7248 * MK_MESSAGE SCBs are not in the per-tid lists.
7249 */
7250 targets++;
7251 if (targets > AHD_SCB_MAX) {
7252 panic("TID LIST LOOP");
7253 }
7254 if (scbid >= ahd->scb_data.numscbs) {
7255 printf("%s: Waiting TID List inconsistency. "
7256 "SCB index == 0x%x, yet numscbs == 0x%x.",
7257 ahd_name(ahd), scbid, ahd->scb_data.numscbs);
7258 ahd_dump_card_state(ahd);
7259 panic("for safety");
7260 }
7261 scb = ahd_lookup_scb(ahd, scbid);
7262 if (scb == NULL) {
7263 printf("%s: SCB = 0x%x Not Active!\n",
7264 ahd_name(ahd), scbid);
7265 panic("Waiting TID List traversal\n");
7266 break;
7267 }
7268 ahd_set_scbptr(ahd, scbid);
7269 tid_next = ahd_inw_scbram(ahd, SCB_NEXT2);
7270 if (ahd_match_scb(ahd, scb, target, channel, CAM_LUN_WILDCARD,
7271 SCB_LIST_NULL, ROLE_UNKNOWN) == 0) {
7272 tid_prev = scbid;
7273 continue;
7274 }
7275
7276 /*
7277 * We found a list of scbs that needs to be searched.
7278 */
7279 if (action == SEARCH_PRINT)
7280 printf(" %d ( ", SCB_GET_TARGET(ahd, scb));
7281 tid_head = scbid;
7282 found += ahd_search_scb_list(ahd, target, channel,
7283 lun, tag, role, status,
7284 action, &tid_head,
7285 SCB_GET_TARGET(ahd, scb));
7286 if (tid_head != scbid)
7287 ahd_stitch_tid_list(ahd, tid_prev, tid_head, tid_next);
7288 if (!SCBID_IS_NULL(tid_head))
7289 tid_prev = tid_head;
7290 if (action == SEARCH_PRINT)
7291 printf(")\n");
7292 }
7293 ahd_set_scbptr(ahd, savedscbptr);
7294 ahd_restore_modes(ahd, saved_modes);
7295 return (found);
7296 }
7297
7298 static int
7299 ahd_search_scb_list(struct ahd_softc *ahd, int target, char channel,
7300 int lun, u_int tag, role_t role, uint32_t status,
7301 ahd_search_action action, u_int *list_head, u_int tid)
7302 {
7303 struct scb *scb;
7304 u_int scbid;
7305 u_int next;
7306 u_int prev;
7307 int found;
7308
7309 AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
7310 found = 0;
7311 prev = SCB_LIST_NULL;
7312 next = *list_head;
7313 for (scbid = next; !SCBID_IS_NULL(scbid); scbid = next) {
7314 if (scbid >= ahd->scb_data.numscbs) {
7315 printf("%s:SCB List inconsistency. "
7316 "SCB == 0x%x, yet numscbs == 0x%x.",
7317 ahd_name(ahd), scbid, ahd->scb_data.numscbs);
7318 ahd_dump_card_state(ahd);
7319 panic("for safety");
7320 }
7321 scb = ahd_lookup_scb(ahd, scbid);
7322 if (scb == NULL) {
7323 printf("%s: SCB = %d Not Active!\n",
7324 ahd_name(ahd), scbid);
7325 panic("Waiting List traversal\n");
7326 }
7327 ahd_set_scbptr(ahd, scbid);
7328 next = ahd_inw_scbram(ahd, SCB_NEXT);
7329 if (ahd_match_scb(ahd, scb, target, channel,
7330 lun, SCB_LIST_NULL, role) == 0) {
7331 prev = scbid;
7332 continue;
7333 }
7334 found++;
7335 switch (action) {
7336 case SEARCH_COMPLETE:
7337 {
7338 cam_status ostat;
7339 cam_status cstat;
7340
7341 ostat = ahd_get_scsi_status(scb);
7342 if (ostat == CAM_REQ_INPROG)
7343 ahd_set_scsi_status(scb, status);
7344 cstat = ahd_get_transaction_status(scb);
7345 if (cstat != CAM_REQ_CMP)
7346 ahd_freeze_scb(scb);
7347 if ((scb->flags & SCB_ACTIVE) == 0)
7348 printf("Inactive SCB in Waiting List\n");
7349 ahd_done(ahd, scb);
7350 /* FALLTHROUGH */
7351 }
7352 case SEARCH_REMOVE:
7353 ahd_rem_wscb(ahd, scbid, prev, next, tid);
7354 if (prev == SCB_LIST_NULL)
7355 *list_head = next;
7356 break;
7357 case SEARCH_PRINT:
7358 printf("0x%x ", scbid);
7359 case SEARCH_COUNT:
7360 prev = scbid;
7361 break;
7362 }
7363 if (found > AHD_SCB_MAX)
7364 panic("SCB LIST LOOP");
7365 }
7366 if (action == SEARCH_COMPLETE
7367 || action == SEARCH_REMOVE)
7368 ahd_outw(ahd, CMDS_PENDING, ahd_inw(ahd, CMDS_PENDING) - found);
7369 return (found);
7370 }
7371
7372 static void
7373 ahd_stitch_tid_list(struct ahd_softc *ahd, u_int tid_prev,
7374 u_int tid_cur, u_int tid_next)
7375 {
7376 AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
7377
7378 if (SCBID_IS_NULL(tid_cur)) {
7379
7380 /* Bypass current TID list */
7381 if (SCBID_IS_NULL(tid_prev)) {
7382 ahd_outw(ahd, WAITING_TID_HEAD, tid_next);
7383 } else {
7384 ahd_set_scbptr(ahd, tid_prev);
7385 ahd_outw(ahd, SCB_NEXT2, tid_next);
7386 }
7387 if (SCBID_IS_NULL(tid_next))
7388 ahd_outw(ahd, WAITING_TID_TAIL, tid_prev);
7389 } else {
7390
7391 /* Stitch through tid_cur */
7392 if (SCBID_IS_NULL(tid_prev)) {
7393 ahd_outw(ahd, WAITING_TID_HEAD, tid_cur);
7394 } else {
7395 ahd_set_scbptr(ahd, tid_prev);
7396 ahd_outw(ahd, SCB_NEXT2, tid_cur);
7397 }
7398 ahd_set_scbptr(ahd, tid_cur);
7399 ahd_outw(ahd, SCB_NEXT2, tid_next);
7400
7401 if (SCBID_IS_NULL(tid_next))
7402 ahd_outw(ahd, WAITING_TID_TAIL, tid_cur);
7403 }
7404 }
7405
7406 /*
7407 * Manipulate the waiting for selection list and return the
7408 * scb that follows the one that we remove.
7409 */
7410 static u_int
7411 ahd_rem_wscb(struct ahd_softc *ahd, u_int scbid,
7412 u_int prev, u_int next, u_int tid)
7413 {
7414 u_int tail_offset;
7415
7416 AHD_ASSERT_MODES(ahd, AHD_MODE_CCHAN_MSK, AHD_MODE_CCHAN_MSK);
7417 if (!SCBID_IS_NULL(prev)) {
7418 ahd_set_scbptr(ahd, prev);
7419 ahd_outw(ahd, SCB_NEXT, next);
7420 }
7421
7422 /*
7423 * SCBs that had MK_MESSAGE set in them will not
7424 * be queued to the per-target lists, so don't
7425 * blindly clear the tail pointer.
7426 */
7427 tail_offset = WAITING_SCB_TAILS + (2 * tid);
7428 if (SCBID_IS_NULL(next)
7429 && ahd_inw(ahd, tail_offset) == scbid)
7430 ahd_outw(ahd, tail_offset, prev);
7431 ahd_add_scb_to_free_list(ahd, scbid);
7432 return (next);
7433 }
7434
7435 /*
7436 * Add the SCB as selected by SCBPTR onto the on chip list of
7437 * free hardware SCBs. This list is empty/unused if we are not
7438 * performing SCB paging.
7439 */
7440 static void
7441 ahd_add_scb_to_free_list(struct ahd_softc *ahd, u_int scbid)
7442 {
7443 #ifdef notdef
7444 /* XXX Need some other mechanism to designate "free". */
7445 /*
7446 * Invalidate the tag so that our abort
7447 * routines don't think it's active.
7448 */
7449 ahd_outb(ahd, SCB_TAG, SCB_LIST_NULL);
7450 #endif
7451 }
7452
7453 /******************************** Error Handling ******************************/
7454 /*
7455 * Abort all SCBs that match the given description (target/channel/lun/tag),
7456 * setting their status to the passed in status if the status has not already
7457 * been modified from CAM_REQ_INPROG. This routine assumes that the sequencer
7458 * is paused before it is called.
7459 */
7460 int
7461 ahd_abort_scbs(struct ahd_softc *ahd, int target, char channel,
7462 int lun, u_int tag, role_t role, uint32_t status)
7463 {
7464 struct scb *scbp;
7465 struct scb *scbp_next;
7466 u_int i, j;
7467 u_int maxtarget;
7468 u_int minlun;
7469 u_int maxlun;
7470 int found;
7471 ahd_mode_state saved_modes;
7472
7473 /* restore this when we're done */
7474 saved_modes = ahd_save_modes(ahd);
7475 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
7476
7477 found = ahd_search_qinfifo(ahd, target, channel, lun, SCB_LIST_NULL,
7478 role, CAM_REQUEUE_REQ, SEARCH_COMPLETE);
7479
7480 /*
7481 * Clean out the busy target table for any untagged commands.
7482 */
7483 i = 0;
7484 maxtarget = 16;
7485 if (target != CAM_TARGET_WILDCARD) {
7486 i = target;
7487 if (channel == 'B')
7488 i += 8;
7489 maxtarget = i + 1;
7490 }
7491
7492 if (lun == CAM_LUN_WILDCARD) {
7493 minlun = 0;
7494 maxlun = AHD_NUM_LUNS_NONPKT;
7495 } else if (lun >= AHD_NUM_LUNS_NONPKT) {
7496 minlun = maxlun = 0;
7497 } else {
7498 minlun = lun;
7499 maxlun = lun + 1;
7500 }
7501
7502 if (role != ROLE_TARGET) {
7503 for (;i < maxtarget; i++) {
7504 for (j = minlun;j < maxlun; j++) {
7505 u_int scbid;
7506 u_int tcl;
7507
7508 tcl = BUILD_TCL_RAW(i, 'A', j);
7509 scbid = ahd_find_busy_tcl(ahd, tcl);
7510 scbp = ahd_lookup_scb(ahd, scbid);
7511 if (scbp == NULL
7512 || ahd_match_scb(ahd, scbp, target, channel,
7513 lun, tag, role) == 0)
7514 continue;
7515 ahd_unbusy_tcl(ahd, BUILD_TCL_RAW(i, 'A', j));
7516 }
7517 }
7518 }
7519
7520 /*
7521 * Don't abort commands that have already completed,
7522 * but haven't quite made it up to the host yet.
7523 */
7524 ahd_flush_qoutfifo(ahd);
7525
7526 /*
7527 * Go through the pending CCB list and look for
7528 * commands for this target that are still active.
7529 * These are other tagged commands that were
7530 * disconnected when the reset occurred.
7531 */
7532 scbp_next = LIST_FIRST(&ahd->pending_scbs);
7533 while (scbp_next != NULL) {
7534 scbp = scbp_next;
7535 scbp_next = LIST_NEXT(scbp, pending_links);
7536 if (ahd_match_scb(ahd, scbp, target, channel, lun, tag, role)) {
7537 cam_status ostat;
7538
7539 ostat = ahd_get_scsi_status(scbp);
7540 if (ostat == CAM_REQ_INPROG)
7541 ahd_set_scsi_status(scbp, status);
7542 if (ahd_get_transaction_status(scbp) != CAM_REQ_CMP)
7543 ahd_freeze_scb(scbp);
7544 if ((scbp->flags & SCB_ACTIVE) == 0)
7545 printf("Inactive SCB on pending list\n");
7546 ahd_done(ahd, scbp);
7547 found++;
7548 }
7549 }
7550 ahd_restore_modes(ahd, saved_modes);
7551 ahd_platform_abort_scbs(ahd, target, channel, lun, tag, role, status);
7552 ahd->flags |= AHD_UPDATE_PEND_CMDS;
7553 return found;
7554 }
7555
7556 static void
7557 ahd_reset_current_bus(struct ahd_softc *ahd)
7558 {
7559 uint8_t scsiseq;
7560
7561 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
7562 ahd_outb(ahd, SIMODE1, ahd_inb(ahd, SIMODE1) & ~ENSCSIRST);
7563 scsiseq = ahd_inb(ahd, SCSISEQ0) & ~(ENSELO|ENARBO|SCSIRSTO);
7564 ahd_outb(ahd, SCSISEQ0, scsiseq | SCSIRSTO);
7565 ahd_flush_device_writes(ahd);
7566 ahd_delay(AHD_BUSRESET_DELAY);
7567 /* Turn off the bus reset */
7568 ahd_outb(ahd, SCSISEQ0, scsiseq);
7569 ahd_flush_device_writes(ahd);
7570 ahd_delay(AHD_BUSRESET_DELAY);
7571 if ((ahd->bugs & AHD_SCSIRST_BUG) != 0) {
7572 /*
7573 * 2A Razor #474
7574 * Certain chip state is not cleared for
7575 * SCSI bus resets that we initiate, so
7576 * we must reset the chip.
7577 */
7578 ahd_reset(ahd, /*reinit*/TRUE);
7579 ahd_intr_enable(ahd, /*enable*/TRUE);
7580 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
7581 }
7582
7583 ahd_clear_intstat(ahd);
7584 }
7585
7586 int
7587 ahd_reset_channel(struct ahd_softc *ahd, char channel, int initiate_reset)
7588 {
7589 struct ahd_devinfo devinfo;
7590 u_int initiator;
7591 u_int target;
7592 u_int max_scsiid;
7593 int found;
7594 u_int fifo;
7595 u_int next_fifo;
7596
7597
7598 ahd->pending_device = NULL;
7599
7600 ahd_compile_devinfo(&devinfo,
7601 CAM_TARGET_WILDCARD,
7602 CAM_TARGET_WILDCARD,
7603 CAM_LUN_WILDCARD,
7604 channel, ROLE_UNKNOWN);
7605 ahd_pause(ahd);
7606
7607 /* Make sure the sequencer is in a safe location. */
7608 ahd_clear_critical_section(ahd);
7609
7610 #if AHD_TARGET_MODE
7611 if ((ahd->flags & AHD_TARGETROLE) != 0) {
7612 ahd_run_tqinfifo(ahd, /*paused*/TRUE);
7613 }
7614 #endif
7615 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
7616
7617 /*
7618 * Disable selections so no automatic hardware
7619 * functions will modify chip state.
7620 */
7621 ahd_outb(ahd, SCSISEQ0, 0);
7622 ahd_outb(ahd, SCSISEQ1, 0);
7623
7624 /*
7625 * Safely shut down our DMA engines. Always start with
7626 * the FIFO that is not currently active (if any are
7627 * actively connected).
7628 */
7629 next_fifo = fifo = ahd_inb(ahd, DFFSTAT) & CURRFIFO;
7630 if (next_fifo > CURRFIFO_1)
7631 /* If disconneced, arbitrarily start with FIFO1. */
7632 next_fifo = fifo = 0;
7633 do {
7634 next_fifo ^= CURRFIFO_1;
7635 ahd_set_modes(ahd, next_fifo, next_fifo);
7636 ahd_outb(ahd, DFCNTRL,
7637 ahd_inb(ahd, DFCNTRL) & ~(SCSIEN|HDMAEN));
7638 while ((ahd_inb(ahd, DFCNTRL) & HDMAENACK) != 0)
7639 ahd_delay(10);
7640 /*
7641 * Set CURRFIFO to the now inactive channel.
7642 */
7643 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
7644 ahd_outb(ahd, DFFSTAT, next_fifo);
7645 } while (next_fifo != fifo);
7646
7647 /*
7648 * Reset the bus if we are initiating this reset
7649 */
7650 ahd_clear_msg_state(ahd);
7651 ahd_outb(ahd, SIMODE1,
7652 ahd_inb(ahd, SIMODE1) & ~(ENBUSFREE|ENSCSIRST|ENBUSFREE));
7653
7654 if (initiate_reset)
7655 ahd_reset_current_bus(ahd);
7656
7657 ahd_clear_intstat(ahd);
7658
7659 /*
7660 * Clean up all the state information for the
7661 * pending transactions on this bus.
7662 */
7663 found = ahd_abort_scbs(ahd, CAM_TARGET_WILDCARD, channel,
7664 CAM_LUN_WILDCARD, SCB_LIST_NULL,
7665 ROLE_UNKNOWN, CAM_SCSI_BUS_RESET);
7666
7667 /*
7668 * Cleanup anything left in the FIFOs.
7669 */
7670 ahd_clear_fifo(ahd, 0);
7671 ahd_clear_fifo(ahd, 1);
7672
7673 /*
7674 * Revert to async/narrow transfers until we renegotiate.
7675 */
7676 max_scsiid = (ahd->features & AHD_WIDE) ? 15 : 7;
7677 for (target = 0; target <= max_scsiid; target++) {
7678
7679 if (ahd->enabled_targets[target] == NULL)
7680 continue;
7681 for (initiator = 0; initiator <= max_scsiid; initiator++) {
7682 struct ahd_devinfo dinfo;
7683
7684 ahd_compile_devinfo(&dinfo, target, initiator,
7685 CAM_LUN_WILDCARD,
7686 'A', ROLE_UNKNOWN);
7687 ahd_set_width(ahd, &dinfo, MSG_EXT_WDTR_BUS_8_BIT,
7688 AHD_TRANS_CUR, /*paused*/TRUE);
7689 ahd_set_syncrate(ahd, &dinfo, /*period*/0,
7690 /*offset*/0, /*ppr_options*/0,
7691 AHD_TRANS_CUR, /*paused*/TRUE);
7692 }
7693 }
7694
7695 #ifdef AHD_TARGET_MODE
7696 max_scsiid = (ahd->features & AHD_WIDE) ? 15 : 7;
7697
7698 /*
7699 * Send an immediate notify ccb to all target more peripheral
7700 * drivers affected by this action.
7701 */
7702 for (target = 0; target <= max_scsiid; target++) {
7703 struct ahd_tmode_tstate* tstate;
7704 u_int lun;
7705
7706 tstate = ahd->enabled_targets[target];
7707 if (tstate == NULL)
7708 continue;
7709 for (lun = 0; lun < AHD_NUM_LUNS; lun++) {
7710 struct ahd_tmode_lstate* lstate;
7711
7712 lstate = tstate->enabled_luns[lun];
7713 if (lstate == NULL)
7714 continue;
7715
7716 ahd_queue_lstate_event(ahd, lstate, CAM_TARGET_WILDCARD,
7717 EVENT_TYPE_BUS_RESET, /*arg*/0);
7718 ahd_send_lstate_events(ahd, lstate);
7719 }
7720 }
7721 #endif
7722
7723 /* Notify the XPT that a bus reset occurred */
7724 ahd_send_async(ahd, devinfo.channel, CAM_TARGET_WILDCARD,
7725 CAM_LUN_WILDCARD, AC_BUS_RESET, NULL);
7726 ahd_restart(ahd);
7727
7728 /*
7729 * Freeze the SIMQ until our poller can determine that
7730 * the bus reset has really gone away. We set the initial
7731 * timer to 0 to have the check performed as soon as possible
7732 * from the timer context.
7733 */
7734 if ((ahd->flags & AHD_RESET_POLL_ACTIVE) == 0) {
7735 ahd->flags |= AHD_RESET_POLL_ACTIVE;
7736 ahd_freeze_simq(ahd);
7737 ahd_timer_reset(&ahd->reset_timer, 0, ahd_reset_poll, ahd);
7738 }
7739 return (found);
7740 }
7741
7742
7743 #define AHD_RESET_POLL_US 1000
7744 static void
7745 ahd_reset_poll(void *arg)
7746 {
7747 struct ahd_softc *ahd;
7748 u_int scsiseq1;
7749 u_long l;
7750 int s;
7751
7752 ahd_list_lock(&l);
7753 ahd = arg;
7754 if (ahd == NULL) {
7755 printf("ahd_reset_poll: Instance %p no longer exists\n", arg);
7756 ahd_list_unlock(&l);
7757 return;
7758 }
7759 ahd_lock(ahd, &s);
7760 ahd_pause(ahd);
7761 ahd_update_modes(ahd);
7762 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
7763 ahd_outb(ahd, CLRSINT1, CLRSCSIRSTI);
7764 if ((ahd_inb(ahd, SSTAT1) & SCSIRSTI) != 0) {
7765 ahd_timer_reset(&ahd->reset_timer, AHD_RESET_POLL_US,
7766 ahd_reset_poll, ahd);
7767 ahd_unpause(ahd);
7768 ahd_unlock(ahd, &s);
7769 ahd_list_unlock(&l);
7770 return;
7771 }
7772
7773 /* Reset is now low. Complete chip reinitialization. */
7774 ahd_outb(ahd, SIMODE1, ahd_inb(ahd, SIMODE1) | ENSCSIRST);
7775 scsiseq1 = ahd_inb(ahd, SCSISEQ_TEMPLATE);
7776 ahd_outb(ahd, SCSISEQ1, scsiseq1 & (ENSELI|ENRSELI|ENAUTOATNP));
7777 ahd_unpause(ahd);
7778 ahd->flags &= ~AHD_RESET_POLL_ACTIVE;
7779 ahd_unlock(ahd, &s);
7780 ahd_release_simq(ahd);
7781 ahd_list_unlock(&l);
7782 }
7783
7784 /**************************** Statistics Processing ***************************/
7785 static void
7786 ahd_stat_timer(void *arg)
7787 {
7788 struct ahd_softc *ahd;
7789 u_long l;
7790 int s;
7791 int enint_coal;
7792
7793 ahd_list_lock(&l);
7794 ahd = arg;
7795 if (ahd == NULL) {
7796 printf("ahd_stat_timer: Instance %p no longer exists\n", arg);
7797 ahd_list_unlock(&l);
7798 return;
7799 }
7800 ahd_lock(ahd, &s);
7801
7802 enint_coal = ahd->hs_mailbox & ENINT_COALESCE;
7803 if (ahd->cmdcmplt_total > ahd->int_coalescing_threshold)
7804 enint_coal |= ENINT_COALESCE;
7805 else if (ahd->cmdcmplt_total < ahd->int_coalescing_stop_threshold)
7806 enint_coal &= ~ENINT_COALESCE;
7807
7808 if (enint_coal != (ahd->hs_mailbox & ENINT_COALESCE)) {
7809 ahd_enable_coalescing(ahd, enint_coal);
7810 #ifdef AHD_DEBUG
7811 if ((ahd_debug & AHD_SHOW_INT_COALESCING) != 0)
7812 printf("%s: Interrupt coalescing "
7813 "now %sabled. Cmds %d\n",
7814 ahd_name(ahd),
7815 (enint_coal & ENINT_COALESCE) ? "en" : "dis",
7816 ahd->cmdcmplt_total);
7817 #endif
7818 }
7819
7820 ahd->cmdcmplt_bucket = (ahd->cmdcmplt_bucket+1) & (AHD_STAT_BUCKETS-1);
7821 ahd->cmdcmplt_total -= ahd->cmdcmplt_counts[ahd->cmdcmplt_bucket];
7822 ahd->cmdcmplt_counts[ahd->cmdcmplt_bucket] = 0;
7823 ahd_timer_reset(&ahd->stat_timer, AHD_STAT_UPDATE_US,
7824 ahd_stat_timer, ahd);
7825 ahd_unlock(ahd, &s);
7826 ahd_list_unlock(&l);
7827 }
7828
7829 /****************************** Status Processing *****************************/
7830 void
7831 ahd_handle_scb_status(struct ahd_softc *ahd, struct scb *scb)
7832 {
7833 if (scb->hscb->shared_data.istatus.scsi_status != 0) {
7834 ahd_handle_scsi_status(ahd, scb);
7835 } else {
7836 ahd_calc_residual(ahd, scb);
7837 ahd_done(ahd, scb);
7838 }
7839 }
7840
7841 void
7842 ahd_handle_scsi_status(struct ahd_softc *ahd, struct scb *scb)
7843 {
7844 struct hardware_scb *hscb;
7845 u_int qfreeze_cnt;
7846
7847 /*
7848 * The sequencer freezes its select-out queue
7849 * anytime a SCSI status error occurs. We must
7850 * handle the error and decrement the QFREEZE count
7851 * to allow the sequencer to continue.
7852 */
7853 hscb = scb->hscb;
7854
7855 /* Freeze the queue until the client sees the error. */
7856 ahd_freeze_devq(ahd, scb);
7857 ahd_freeze_scb(scb);
7858 qfreeze_cnt = ahd_inw(ahd, QFREEZE_COUNT);
7859 if (qfreeze_cnt == 0) {
7860 printf("%s: Bad status with 0 qfreeze count!\n", ahd_name(ahd));
7861 } else {
7862 qfreeze_cnt--;
7863 ahd_outw(ahd, QFREEZE_COUNT, qfreeze_cnt);
7864 }
7865 if (qfreeze_cnt == 0)
7866 ahd_outb(ahd, SEQ_FLAGS2,
7867 ahd_inb(ahd, SEQ_FLAGS2) & ~SELECTOUT_QFROZEN);
7868
7869 /* Don't want to clobber the original sense code */
7870 if ((scb->flags & SCB_SENSE) != 0) {
7871 /*
7872 * Clear the SCB_SENSE Flag and perform
7873 * a normal command completion.
7874 */
7875 scb->flags &= ~SCB_SENSE;
7876 ahd_set_transaction_status(scb, CAM_AUTOSENSE_FAIL);
7877 ahd_done(ahd, scb);
7878 return;
7879 }
7880 ahd_set_scsi_status(scb, hscb->shared_data.istatus.scsi_status);
7881 ahd_set_xfer_status(scb, hscb->shared_data.istatus.scsi_status);
7882 switch (hscb->shared_data.istatus.scsi_status) {
7883 case STATUS_PKT_SENSE:
7884 {
7885 struct scsi_status_iu_header *siu;
7886
7887 ahd_sync_sense(ahd, scb, BUS_DMASYNC_POSTREAD);
7888 siu = (struct scsi_status_iu_header *)scb->sense_data;
7889 ahd_set_scsi_status(scb, siu->status);
7890 #ifdef AHD_DEBUG
7891 if ((ahd_debug & AHD_SHOW_SENSE) != 0) {
7892 ahd_print_path(ahd, scb);
7893 printf("SCB 0x%x Received PKT Status of 0x%x\n",
7894 SCB_GET_TAG(scb), siu->status);
7895 }
7896 #endif
7897 if ((siu->flags & SIU_RSPVALID) != 0) {
7898 scsipi_printaddr(scb->xs->xs_periph);
7899 if (scsi_4btoul(siu->pkt_failures_length) < 4) {
7900 printf("Unable to parse pkt_failures\n");
7901 } else {
7902
7903 switch (SIU_PKTFAIL_CODE(siu)) {
7904 case SIU_PFC_NONE:
7905 printf("No packet failure found\n");
7906 break;
7907 case SIU_PFC_CIU_FIELDS_INVALID:
7908 printf("Invalid Command IU Field\n");
7909 break;
7910 case SIU_PFC_TMF_NOT_SUPPORTED:
7911 printf("TMF not supportd\n");
7912 break;
7913 case SIU_PFC_TMF_FAILED:
7914 printf("TMF failed\n");
7915 break;
7916 case SIU_PFC_INVALID_TYPE_CODE:
7917 printf("Invalid L_Q Type code\n");
7918 break;
7919 case SIU_PFC_ILLEGAL_REQUEST:
7920 printf("Illegal request\n");
7921 default:
7922 break;
7923 }
7924 }
7925 if (siu->status == SCSI_STATUS_OK)
7926 ahd_set_transaction_status(scb,
7927 CAM_REQ_CMP_ERR);
7928 }
7929 if ((siu->flags & SIU_SNSVALID) != 0) {
7930 scb->flags |= SCB_PKT_SENSE;
7931 #ifdef AHD_DEBUG
7932 if ((ahd_debug & AHD_SHOW_SENSE) != 0) {
7933 printf("Sense data available (%d)\n",
7934 siu->sense_length[0]);
7935 printf("SK 0x%x ASC 0x%x ASCQ 0x%x\n",
7936 ((uint8_t)scb->sense_data[
7937 SIU_SENSE_OFFSET(siu)+2]) & 0x0F,
7938 ((uint8_t)scb->sense_data[
7939 SIU_SENSE_OFFSET(siu)+12]),
7940 ((uint8_t)scb->sense_data[
7941 SIU_SENSE_OFFSET(siu)+13]));
7942 }
7943 #endif
7944 }
7945 ahd_done(ahd, scb);
7946 break;
7947 }
7948 case SCSI_STATUS_CMD_TERMINATED:
7949 case SCSI_STATUS_CHECK_COND:
7950 {
7951 struct ahd_devinfo devinfo;
7952 struct ahd_dma_seg *sg;
7953 struct scsi_request_sense *sc;
7954 struct ahd_initiator_tinfo *targ_info;
7955 struct ahd_tmode_tstate *tstate;
7956 struct ahd_transinfo *tinfo;
7957 #ifdef AHD_DEBUG
7958 if (ahd_debug & AHD_SHOW_SENSE) {
7959 ahd_print_path(ahd, scb);
7960 printf("SCB %d: requests Check Status\n",
7961 SCB_GET_TAG(scb));
7962 }
7963 #endif
7964
7965 if (ahd_perform_autosense(scb) == 0)
7966 break;
7967
7968 ahd_compile_devinfo(&devinfo, SCB_GET_OUR_ID(scb),
7969 SCB_GET_TARGET(ahd, scb),
7970 SCB_GET_LUN(scb),
7971 SCB_GET_CHANNEL(ahd, scb),
7972 ROLE_INITIATOR);
7973 targ_info = ahd_fetch_transinfo(ahd,
7974 devinfo.channel,
7975 devinfo.our_scsiid,
7976 devinfo.target,
7977 &tstate);
7978 tinfo = &targ_info->curr;
7979 sg = scb->sg_list;
7980 sc = (struct scsi_request_sense *)hscb->shared_data.idata.cdb;
7981 /*
7982 * Save off the residual if there is one.
7983 */
7984 ahd_update_residual(ahd, scb);
7985 #ifdef AHD_DEBUG
7986 if (ahd_debug & AHD_SHOW_SENSE) {
7987 ahd_print_path(ahd, scb);
7988 printf("Sending Sense\n");
7989 }
7990 #endif
7991 scb->sg_count = 0;
7992 sg = ahd_sg_setup(ahd, scb, sg, ahd_get_sense_bufaddr(ahd, scb),
7993 ahd_get_sense_bufsize(ahd, scb),
7994 /*last*/TRUE);
7995 memset(sc, 0, sizeof(*sc));
7996 sc->opcode = SCSI_REQUEST_SENSE;
7997 sc->length = ahd_get_sense_bufsize(ahd, scb);
7998
7999 /*
8000 * We can't allow the target to disconnect.
8001 * This will be an untagged transaction and
8002 * having the target disconnect will make this
8003 * transaction indistinguishable from outstanding
8004 * tagged transactions.
8005 */
8006 hscb->control = 0;
8007
8008 /*
8009 * This request sense could be because the
8010 * the device lost power or in some other
8011 * way has lost our transfer negotiations.
8012 * Renegotiate if appropriate. Unit attention
8013 * errors will be reported before any data
8014 * phases occur.
8015 */
8016 if (ahd_get_residual(scb) == ahd_get_transfer_length(scb)) {
8017 ahd_update_neg_request(ahd, &devinfo,
8018 tstate, targ_info,
8019 AHD_NEG_IF_NON_ASYNC);
8020 }
8021 if (tstate->auto_negotiate & devinfo.target_mask) {
8022 hscb->control |= MK_MESSAGE;
8023 scb->flags &=
8024 ~(SCB_NEGOTIATE|SCB_ABORT|SCB_DEVICE_RESET);
8025 scb->flags |= SCB_AUTO_NEGOTIATE;
8026 }
8027 hscb->cdb_len = sizeof(*sc);
8028 ahd_setup_data_scb(ahd, scb);
8029 scb->flags |= SCB_SENSE;
8030 ahd_queue_scb(ahd, scb);
8031 /*
8032 * Ensure we have enough time to actually
8033 * retrieve the sense.
8034 */
8035 ahd_scb_timer_reset(scb, 5 * 1000000);
8036 break;
8037 }
8038 case SCSI_STATUS_OK:
8039 printf("%s: Interrupted for status of 0? (SCB 0x%x)\n",
8040 ahd_name(ahd), SCB_GET_TAG(scb));
8041 /* FALLTHROUGH */
8042 default:
8043 ahd_done(ahd, scb);
8044 break;
8045 }
8046 }
8047
8048 /*
8049 * Calculate the residual for a just completed SCB.
8050 */
8051 void
8052 ahd_calc_residual(struct ahd_softc *ahd, struct scb *scb)
8053 {
8054 struct hardware_scb *hscb;
8055 struct initiator_status *spkt;
8056 uint32_t sgptr;
8057 uint32_t resid_sgptr;
8058 uint32_t resid;
8059
8060 /*
8061 * 5 cases.
8062 * 1) No residual.
8063 * SG_STATUS_VALID clear in sgptr.
8064 * 2) Transferless command
8065 * 3) Never performed any transfers.
8066 * sgptr has SG_FULL_RESID set.
8067 * 4) No residual but target did not
8068 * save data pointers after the
8069 * last transfer, so sgptr was
8070 * never updated.
8071 * 5) We have a partial residual.
8072 * Use residual_sgptr to determine
8073 * where we are.
8074 */
8075
8076 hscb = scb->hscb;
8077 sgptr = ahd_le32toh(hscb->sgptr);
8078 if ((sgptr & SG_STATUS_VALID) == 0)
8079 /* Case 1 */
8080 return;
8081 sgptr &= ~SG_STATUS_VALID;
8082
8083 if ((sgptr & SG_LIST_NULL) != 0)
8084 /* Case 2 */
8085 return;
8086
8087 /*
8088 * Residual fields are the same in both
8089 * target and initiator status packets,
8090 * so we can always use the initiator fields
8091 * regardless of the role for this SCB.
8092 */
8093 spkt = &hscb->shared_data.istatus;
8094 resid_sgptr = ahd_le32toh(spkt->residual_sgptr);
8095 if ((sgptr & SG_FULL_RESID) != 0) {
8096 /* Case 3 */
8097 resid = ahd_get_transfer_length(scb);
8098 } else if ((resid_sgptr & SG_LIST_NULL) != 0) {
8099 /* Case 4 */
8100 return;
8101 } else if ((resid_sgptr & SG_OVERRUN_RESID) != 0) {
8102 ahd_print_path(ahd, scb);
8103 printf("data overrun detected Tag == 0x%x.\n",
8104 SCB_GET_TAG(scb));
8105 ahd_freeze_devq(ahd, scb);
8106 ahd_set_transaction_status(scb, CAM_DATA_RUN_ERR);
8107 ahd_freeze_scb(scb);
8108 return;
8109 } else if ((resid_sgptr & ~SG_PTR_MASK) != 0) {
8110 panic("Bogus resid sgptr value 0x%x\n", resid_sgptr);
8111 /* NOTREACHED */
8112 } else {
8113 struct ahd_dma_seg *sg;
8114
8115 /*
8116 * Remainder of the SG where the transfer
8117 * stopped.
8118 */
8119 resid = ahd_le32toh(spkt->residual_datacnt) & AHD_SG_LEN_MASK;
8120 sg = ahd_sg_bus_to_virt(ahd, scb, resid_sgptr & SG_PTR_MASK);
8121
8122 /* The residual sg_ptr always points to the next sg */
8123 sg--;
8124
8125 /*
8126 * Add up the contents of all residual
8127 * SG segments that are after the SG where
8128 * the transfer stopped.
8129 */
8130 while ((ahd_le32toh(sg->len) & AHD_DMA_LAST_SEG) == 0) {
8131 sg++;
8132 resid += ahd_le32toh(sg->len) & AHD_SG_LEN_MASK;
8133 }
8134 }
8135
8136 if ((scb->flags & SCB_SENSE) == 0)
8137 ahd_set_residual(scb, resid);
8138 /*else
8139 ahd_set_sense_residual(scb, resid);*/
8140
8141 #ifdef AHD_DEBUG
8142 if ((ahd_debug & AHD_SHOW_MISC) != 0) {
8143 ahd_print_path(ahd, scb);
8144 printf("Handled %sResidual of %d bytes\n",
8145 (scb->flags & SCB_SENSE) ? "Sense " : "", resid);
8146 }
8147 #endif
8148 }
8149
8150 /******************************* Target Mode **********************************/
8151 #ifdef AHD_TARGET_MODE
8152 /*
8153 * Add a target mode event to this lun's queue
8154 */
8155 static void
8156 ahd_queue_lstate_event(struct ahd_softc *ahd, struct ahd_tmode_lstate *lstate,
8157 u_int initiator_id, u_int event_type, u_int event_arg)
8158 {
8159 struct ahd_tmode_event *event;
8160 int pending;
8161
8162 xpt_freeze_devq(lstate->path, /*count*/1);
8163 if (lstate->event_w_idx >= lstate->event_r_idx)
8164 pending = lstate->event_w_idx - lstate->event_r_idx;
8165 else
8166 pending = AHD_TMODE_EVENT_BUFFER_SIZE + 1
8167 - (lstate->event_r_idx - lstate->event_w_idx);
8168
8169 if (event_type == EVENT_TYPE_BUS_RESET
8170 || event_type == MSG_BUS_DEV_RESET) {
8171 /*
8172 * Any earlier events are irrelevant, so reset our buffer.
8173 * This has the effect of allowing us to deal with reset
8174 * floods (an external device holding down the reset line)
8175 * without losing the event that is really interesting.
8176 */
8177 lstate->event_r_idx = 0;
8178 lstate->event_w_idx = 0;
8179 xpt_release_devq(lstate->path, pending, /*runqueue*/FALSE);
8180 }
8181
8182 if (pending == AHD_TMODE_EVENT_BUFFER_SIZE) {
8183 xpt_print_path(lstate->path);
8184 printf("immediate event %x:%x lost\n",
8185 lstate->event_buffer[lstate->event_r_idx].event_type,
8186 lstate->event_buffer[lstate->event_r_idx].event_arg);
8187 lstate->event_r_idx++;
8188 if (lstate->event_r_idx == AHD_TMODE_EVENT_BUFFER_SIZE)
8189 lstate->event_r_idx = 0;
8190 xpt_release_devq(lstate->path, /*count*/1, /*runqueue*/FALSE);
8191 }
8192
8193 event = &lstate->event_buffer[lstate->event_w_idx];
8194 event->initiator_id = initiator_id;
8195 event->event_type = event_type;
8196 event->event_arg = event_arg;
8197 lstate->event_w_idx++;
8198 if (lstate->event_w_idx == AHD_TMODE_EVENT_BUFFER_SIZE)
8199 lstate->event_w_idx = 0;
8200 }
8201
8202 /*
8203 * Send any target mode events queued up waiting
8204 * for immediate notify resources.
8205 */
8206 void
8207 ahd_send_lstate_events(struct ahd_softc *ahd, struct ahd_tmode_lstate *lstate)
8208 {
8209 struct ccb_hdr *ccbh;
8210 struct ccb_immed_notify *inot;
8211
8212 while (lstate->event_r_idx != lstate->event_w_idx
8213 && (ccbh = SLIST_FIRST(&lstate->immed_notifies)) != NULL) {
8214 struct ahd_tmode_event *event;
8215
8216 event = &lstate->event_buffer[lstate->event_r_idx];
8217 SLIST_REMOVE_HEAD(&lstate->immed_notifies, sim_links.sle);
8218 inot = (struct ccb_immed_notify *)ccbh;
8219 switch (event->event_type) {
8220 case EVENT_TYPE_BUS_RESET:
8221 ccbh->status = CAM_SCSI_BUS_RESET|CAM_DEV_QFRZN;
8222 break;
8223 default:
8224 ccbh->status = CAM_MESSAGE_RECV|CAM_DEV_QFRZN;
8225 inot->message_args[0] = event->event_type;
8226 inot->message_args[1] = event->event_arg;
8227 break;
8228 }
8229 inot->initiator_id = event->initiator_id;
8230 inot->sense_len = 0;
8231 xpt_done((union ccb *)inot);
8232 lstate->event_r_idx++;
8233 if (lstate->event_r_idx == AHD_TMODE_EVENT_BUFFER_SIZE)
8234 lstate->event_r_idx = 0;
8235 }
8236 }
8237 #endif
8238
8239 /******************** Sequencer Program Patching/Download *********************/
8240
8241 #ifdef AHD_DUMP_SEQ
8242 void
8243 ahd_dumpseq(struct ahd_softc* ahd)
8244 {
8245 int i;
8246 int max_prog;
8247
8248 max_prog = 2048;
8249
8250 ahd_outb(ahd, SEQCTL0, PERRORDIS|FAILDIS|FASTMODE|LOADRAM);
8251 ahd_outb(ahd, PRGMCNT, 0);
8252 ahd_outb(ahd, PRGMCNT+1, 0);
8253 for (i = 0; i < max_prog; i++) {
8254 uint8_t ins_bytes[4];
8255
8256 ahd_insb(ahd, SEQRAM, ins_bytes, 4);
8257 printf("0x%08x\n", ins_bytes[0] << 24
8258 | ins_bytes[1] << 16
8259 | ins_bytes[2] << 8
8260 | ins_bytes[3]);
8261 }
8262 }
8263 #endif
8264
8265 static void
8266 ahd_loadseq(struct ahd_softc *ahd)
8267 {
8268 struct cs cs_table[num_critical_sections];
8269 u_int begin_set[num_critical_sections];
8270 u_int end_set[num_critical_sections];
8271 struct patch *cur_patch;
8272 u_int cs_count;
8273 u_int cur_cs;
8274 u_int i;
8275 int downloaded;
8276 u_int skip_addr;
8277 u_int sg_prefetch_cnt;
8278 u_int sg_prefetch_cnt_limit;
8279 u_int sg_prefetch_align;
8280 u_int sg_size;
8281 uint8_t download_consts[DOWNLOAD_CONST_COUNT];
8282
8283 if (bootverbose)
8284 printf("%s: Downloading Sequencer Program...",
8285 ahd_name(ahd));
8286
8287 #if DOWNLOAD_CONST_COUNT != 7
8288 #error "Download Const Mismatch"
8289 #endif
8290 /*
8291 * Start out with 0 critical sections
8292 * that apply to this firmware load.
8293 */
8294 cs_count = 0;
8295 cur_cs = 0;
8296 memset(begin_set, 0, sizeof(begin_set));
8297 memset(end_set, 0, sizeof(end_set));
8298
8299 /*
8300 * Setup downloadable constant table.
8301 *
8302 * The computation for the S/G prefetch variables is
8303 * a bit complicated. We would like to always fetch
8304 * in terms of cachelined sized increments. However,
8305 * if the cacheline is not an even multiple of the
8306 * SG element size or is larger than our SG RAM, using
8307 * just the cache size might leave us with only a portion
8308 * of an SG element at the tail of a prefetch. If the
8309 * cacheline is larger than our S/G prefetch buffer less
8310 * the size of an SG element, we may round down to a cacheline
8311 * that doesn't contain any or all of the S/G of interest
8312 * within the bounds of our S/G ram. Provide variables to
8313 * the sequencer that will allow it to handle these edge
8314 * cases.
8315 */
8316 /* Start by aligning to the nearest cacheline. */
8317 sg_prefetch_align = ahd->pci_cachesize;
8318 if (sg_prefetch_align == 0)
8319 sg_prefetch_align = 8;
8320 /* Round down to the nearest power of 2. */
8321 while (powerof2(sg_prefetch_align) == 0)
8322 sg_prefetch_align--;
8323 /*
8324 * If the cacheline boundary is greater than half our prefetch RAM
8325 * we risk not being able to fetch even a single complete S/G
8326 * segment if we align to that boundary.
8327 */
8328 if (sg_prefetch_align > CCSGADDR_MAX/2)
8329 sg_prefetch_align = CCSGADDR_MAX/2;
8330 /* Start by fetching a single cacheline. */
8331 sg_prefetch_cnt = sg_prefetch_align;
8332 /*
8333 * Increment the prefetch count by cachelines until
8334 * at least one S/G element will fit.
8335 */
8336 sg_size = sizeof(struct ahd_dma_seg);
8337 if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0)
8338 sg_size = sizeof(struct ahd_dma64_seg);
8339 while (sg_prefetch_cnt < sg_size)
8340 sg_prefetch_cnt += sg_prefetch_align;
8341 /*
8342 * If the cacheline is not an even multiple of
8343 * the S/G size, we may only get a partial S/G when
8344 * we align. Add a cacheline if this is the case.
8345 */
8346 if ((sg_prefetch_align % sg_size) != 0
8347 && (sg_prefetch_cnt < CCSGADDR_MAX))
8348 sg_prefetch_cnt += sg_prefetch_align;
8349 /*
8350 * Lastly, compute a value that the sequencer can use
8351 * to determine if the remainder of the CCSGRAM buffer
8352 * has a full S/G element in it.
8353 */
8354 sg_prefetch_cnt_limit = -(sg_prefetch_cnt - sg_size + 1);
8355 download_consts[SG_PREFETCH_CNT] = sg_prefetch_cnt;
8356 download_consts[SG_PREFETCH_CNT_LIMIT] = sg_prefetch_cnt_limit;
8357 download_consts[SG_PREFETCH_ALIGN_MASK] = ~(sg_prefetch_align - 1);
8358 download_consts[SG_PREFETCH_ADDR_MASK] = (sg_prefetch_align - 1);
8359 download_consts[SG_SIZEOF] = sg_size;
8360 download_consts[PKT_OVERRUN_BUFOFFSET] =
8361 (ahd->overrun_buf - (uint8_t *)ahd->qoutfifo) / 256;
8362 download_consts[SCB_TRANSFER_SIZE] = SCB_TRANSFER_SIZE_1BYTE_LUN;
8363 cur_patch = patches;
8364 downloaded = 0;
8365 skip_addr = 0;
8366 ahd_outb(ahd, SEQCTL0, PERRORDIS|FAILDIS|FASTMODE|LOADRAM);
8367 ahd_outb(ahd, PRGMCNT, 0);
8368 ahd_outb(ahd, PRGMCNT+1, 0);
8369
8370 for (i = 0; i < sizeof(seqprog)/4; i++) {
8371 if (ahd_check_patch(ahd, &cur_patch, i, &skip_addr) == 0) {
8372 /*
8373 * Don't download this instruction as it
8374 * is in a patch that was removed.
8375 */
8376 continue;
8377 }
8378 /*
8379 * Move through the CS table until we find a CS
8380 * that might apply to this instruction.
8381 */
8382 for (; cur_cs < num_critical_sections; cur_cs++) {
8383 if (critical_sections[cur_cs].end <= i) {
8384 if (begin_set[cs_count] == TRUE
8385 && end_set[cs_count] == FALSE) {
8386 cs_table[cs_count].end = downloaded;
8387 end_set[cs_count] = TRUE;
8388 cs_count++;
8389 }
8390 continue;
8391 }
8392 if (critical_sections[cur_cs].begin <= i
8393 && begin_set[cs_count] == FALSE) {
8394 cs_table[cs_count].begin = downloaded;
8395 begin_set[cs_count] = TRUE;
8396 }
8397 break;
8398 }
8399 ahd_download_instr(ahd, i, download_consts);
8400 downloaded++;
8401 }
8402
8403 ahd->num_critical_sections = cs_count;
8404 if (cs_count != 0) {
8405
8406 cs_count *= sizeof(struct cs);
8407 ahd->critical_sections = malloc(cs_count, M_DEVBUF, M_NOWAIT);
8408 if (ahd->critical_sections == NULL)
8409 panic("ahd_loadseq: Could not malloc");
8410 memcpy(ahd->critical_sections, cs_table, cs_count);
8411 }
8412 ahd_outb(ahd, SEQCTL0, PERRORDIS|FAILDIS|FASTMODE);
8413
8414 if (bootverbose) {
8415 printf(" %d instructions downloaded\n", downloaded);
8416 printf("%s: Features 0x%x, Bugs 0x%x, Flags 0x%x\n",
8417 ahd_name(ahd), ahd->features, ahd->bugs, ahd->flags);
8418 }
8419 }
8420
8421 static int
8422 ahd_check_patch(struct ahd_softc *ahd, struct patch **start_patch,
8423 u_int start_instr, u_int *skip_addr)
8424 {
8425 struct patch *cur_patch;
8426 struct patch *last_patch;
8427 u_int num_patches;
8428
8429 num_patches = sizeof(patches)/sizeof(struct patch);
8430 last_patch = &patches[num_patches];
8431 cur_patch = *start_patch;
8432
8433 while (cur_patch < last_patch && start_instr == cur_patch->begin) {
8434
8435 if (cur_patch->patch_func(ahd) == 0) {
8436
8437 /* Start rejecting code */
8438 *skip_addr = start_instr + cur_patch->skip_instr;
8439 cur_patch += cur_patch->skip_patch;
8440 } else {
8441 /* Accepted this patch. Advance to the next
8442 * one and wait for our intruction pointer to
8443 * hit this point.
8444 */
8445 cur_patch++;
8446 }
8447 }
8448
8449 *start_patch = cur_patch;
8450 if (start_instr < *skip_addr)
8451 /* Still skipping */
8452 return (0);
8453
8454 return (1);
8455 }
8456
8457 static u_int
8458 ahd_resolve_seqaddr(struct ahd_softc *ahd, u_int address)
8459 {
8460 struct patch *cur_patch;
8461 int address_offset;
8462 u_int skip_addr;
8463 u_int i;
8464
8465 address_offset = 0;
8466 cur_patch = patches;
8467 skip_addr = 0;
8468
8469 for (i = 0; i < address;) {
8470
8471 ahd_check_patch(ahd, &cur_patch, i, &skip_addr);
8472
8473 if (skip_addr > i) {
8474 int end_addr;
8475
8476 end_addr = MIN(address, skip_addr);
8477 address_offset += end_addr - i;
8478 i = skip_addr;
8479 } else {
8480 i++;
8481 }
8482 }
8483 return (address - address_offset);
8484 }
8485
8486 static void
8487 ahd_download_instr(struct ahd_softc *ahd, u_int instrptr, uint8_t *dconsts)
8488 {
8489 union ins_formats instr;
8490 struct ins_format1 *fmt1_ins;
8491 struct ins_format3 *fmt3_ins;
8492 u_int opcode;
8493
8494 /*
8495 * The firmware is always compiled into a little endian format.
8496 */
8497 instr.integer = ahd_le32toh(*(uint32_t*)&seqprog[instrptr * 4]);
8498
8499 fmt1_ins = &instr.format1;
8500 fmt3_ins = NULL;
8501
8502 /* Pull the opcode */
8503 opcode = instr.format1.opcode;
8504 switch (opcode) {
8505 case AIC_OP_JMP:
8506 case AIC_OP_JC:
8507 case AIC_OP_JNC:
8508 case AIC_OP_CALL:
8509 case AIC_OP_JNE:
8510 case AIC_OP_JNZ:
8511 case AIC_OP_JE:
8512 case AIC_OP_JZ:
8513 {
8514 fmt3_ins = &instr.format3;
8515 fmt3_ins->address = ahd_resolve_seqaddr(ahd, fmt3_ins->address);
8516 /* FALLTHROUGH */
8517 }
8518 case AIC_OP_OR:
8519 case AIC_OP_AND:
8520 case AIC_OP_XOR:
8521 case AIC_OP_ADD:
8522 case AIC_OP_ADC:
8523 case AIC_OP_BMOV:
8524 if (fmt1_ins->parity != 0) {
8525 fmt1_ins->immediate = dconsts[fmt1_ins->immediate];
8526 }
8527 fmt1_ins->parity = 0;
8528 /* FALLTHROUGH */
8529 case AIC_OP_ROL:
8530 {
8531 int i, count;
8532
8533 /* Calculate odd parity for the instruction */
8534 for (i = 0, count = 0; i < 31; i++) {
8535 uint32_t mask;
8536
8537 mask = 0x01 << i;
8538 if ((instr.integer & mask) != 0)
8539 count++;
8540 }
8541 if ((count & 0x01) == 0)
8542 instr.format1.parity = 1;
8543
8544 /* The sequencer is a little endian CPU */
8545 instr.integer = ahd_htole32(instr.integer);
8546 ahd_outsb(ahd, SEQRAM, instr.bytes, 4);
8547 break;
8548 }
8549 default:
8550 panic("Unknown opcode encountered in seq program");
8551 break;
8552 }
8553 }
8554
8555 static int
8556 ahd_probe_stack_size(struct ahd_softc *ahd)
8557 {
8558 int last_probe;
8559
8560 last_probe = 0;
8561 while (1) {
8562 int i;
8563
8564 /*
8565 * We avoid using 0 as a pattern to avoid
8566 * confusion if the stack implementation
8567 * "back-fills" with zeros when "poping'
8568 * entries.
8569 */
8570 for (i = 1; i <= last_probe+1; i++) {
8571 ahd_outb(ahd, STACK, i & 0xFF);
8572 ahd_outb(ahd, STACK, (i >> 8) & 0xFF);
8573 }
8574
8575 /* Verify */
8576 for (i = last_probe+1; i > 0; i--) {
8577 u_int stack_entry;
8578
8579 stack_entry = ahd_inb(ahd, STACK)
8580 |(ahd_inb(ahd, STACK) << 8);
8581 if (stack_entry != i)
8582 goto sized;
8583 }
8584 last_probe++;
8585 }
8586 sized:
8587 return (last_probe);
8588 }
8589
8590 void
8591 ahd_dump_all_cards_state(void)
8592 {
8593 struct ahd_softc *list_ahd;
8594
8595 TAILQ_FOREACH(list_ahd, &ahd_tailq, links) {
8596 ahd_dump_card_state(list_ahd);
8597 }
8598 }
8599
8600 int
8601 ahd_print_register(ahd_reg_parse_entry_t *table, u_int num_entries,
8602 const char *name, u_int address, u_int value,
8603 u_int *cur_column, u_int wrap_point)
8604 {
8605 int printed;
8606 u_int printed_mask;
8607 char line[1024];
8608
8609 line[0] = 0;
8610
8611 if (cur_column != NULL && *cur_column >= wrap_point) {
8612 printf("\n");
8613 *cur_column = 0;
8614 }
8615 printed = snprintf(line, sizeof(line), "%s[0x%x]", name, value);
8616 if (table == NULL) {
8617 printed += snprintf(&line[printed], (sizeof line) - printed,
8618 " ");
8619 printf("%s", line);
8620 if (cur_column != NULL)
8621 *cur_column += printed;
8622 return (printed);
8623 }
8624 printed_mask = 0;
8625 while (printed_mask != 0xFF) {
8626 int entry;
8627
8628 for (entry = 0; entry < num_entries; entry++) {
8629 if (((value & table[entry].mask)
8630 != table[entry].value)
8631 || ((printed_mask & table[entry].mask)
8632 == table[entry].mask))
8633 continue;
8634 printed += snprintf(&line[printed],
8635 (sizeof line) - printed, "%s%s",
8636 printed_mask == 0 ? ":(" : "|",
8637 table[entry].name);
8638 printed_mask |= table[entry].mask;
8639
8640 break;
8641 }
8642 if (entry >= num_entries)
8643 break;
8644 }
8645 if (printed_mask != 0)
8646 printed += snprintf(&line[printed],
8647 (sizeof line) - printed, ") ");
8648 else
8649 printed += snprintf(&line[printed],
8650 (sizeof line) - printed, " ");
8651 if (cur_column != NULL)
8652 *cur_column += printed;
8653 printf("%s", line);
8654
8655 return (printed);
8656 }
8657
8658 void
8659 ahd_dump_card_state(struct ahd_softc *ahd)
8660 {
8661 struct scb *scb;
8662 ahd_mode_state saved_modes;
8663 u_int dffstat;
8664 int paused;
8665 u_int scb_index;
8666 u_int saved_scb_index;
8667 u_int cur_col;
8668 int i;
8669
8670 if (ahd_is_paused(ahd)) {
8671 paused = 1;
8672 } else {
8673 paused = 0;
8674 ahd_pause(ahd);
8675 }
8676 saved_modes = ahd_save_modes(ahd);
8677 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
8678 printf(">>>>>>>>>>>>>>>>>> Dump Card State Begins <<<<<<<<<<<<<<<<<\n"
8679 "%s: Dumping Card State at program address 0x%x Mode 0x%x\n",
8680 ahd_name(ahd),
8681 ahd_inb(ahd, CURADDR) | (ahd_inb(ahd, CURADDR+1) << 8),
8682 ahd_build_mode_state(ahd, ahd->saved_src_mode,
8683 ahd->saved_dst_mode));
8684 if (paused)
8685 printf("Card was paused\n");
8686
8687 if (ahd_check_cmdcmpltqueues(ahd))
8688 printf("Completions are pending\n");
8689 /*
8690 * Mode independent registers.
8691 */
8692 cur_col = 0;
8693 ahd_hs_mailbox_print(ahd_inb(ahd, LOCAL_HS_MAILBOX), &cur_col, 50);
8694 ahd_intctl_print(ahd_inb(ahd, INTCTL), &cur_col, 50);
8695 ahd_seqintstat_print(ahd_inb(ahd, SEQINTSTAT), &cur_col, 50);
8696 ahd_saved_mode_print(ahd_inb(ahd, SAVED_MODE), &cur_col, 50);
8697 ahd_dffstat_print(ahd_inb(ahd, DFFSTAT), &cur_col, 50);
8698 ahd_scsisigi_print(ahd_inb(ahd, SCSISIGI), &cur_col, 50);
8699 ahd_scsiphase_print(ahd_inb(ahd, SCSIPHASE), &cur_col, 50);
8700 ahd_scsibus_print(ahd_inb(ahd, SCSIBUS), &cur_col, 50);
8701 ahd_lastphase_print(ahd_inb(ahd, LASTPHASE), &cur_col, 50);
8702 ahd_scsiseq0_print(ahd_inb(ahd, SCSISEQ0), &cur_col, 50);
8703 ahd_scsiseq1_print(ahd_inb(ahd, SCSISEQ1), &cur_col, 50);
8704 ahd_seqctl0_print(ahd_inb(ahd, SEQCTL0), &cur_col, 50);
8705 ahd_seqintctl_print(ahd_inb(ahd, SEQINTCTL), &cur_col, 50);
8706 ahd_seq_flags_print(ahd_inb(ahd, SEQ_FLAGS), &cur_col, 50);
8707 ahd_seq_flags2_print(ahd_inb(ahd, SEQ_FLAGS2), &cur_col, 50);
8708 ahd_sstat0_print(ahd_inb(ahd, SSTAT0), &cur_col, 50);
8709 ahd_sstat1_print(ahd_inb(ahd, SSTAT1), &cur_col, 50);
8710 ahd_sstat2_print(ahd_inb(ahd, SSTAT2), &cur_col, 50);
8711 ahd_sstat3_print(ahd_inb(ahd, SSTAT3), &cur_col, 50);
8712 ahd_perrdiag_print(ahd_inb(ahd, PERRDIAG), &cur_col, 50);
8713 ahd_simode1_print(ahd_inb(ahd, SIMODE1), &cur_col, 50);
8714 ahd_lqistat0_print(ahd_inb(ahd, LQISTAT0), &cur_col, 50);
8715 ahd_lqistat1_print(ahd_inb(ahd, LQISTAT1), &cur_col, 50);
8716 ahd_lqistat2_print(ahd_inb(ahd, LQISTAT2), &cur_col, 50);
8717 ahd_lqostat0_print(ahd_inb(ahd, LQOSTAT0), &cur_col, 50);
8718 ahd_lqostat1_print(ahd_inb(ahd, LQOSTAT1), &cur_col, 50);
8719 ahd_lqostat2_print(ahd_inb(ahd, LQOSTAT2), &cur_col, 50);
8720 printf("\n");
8721 printf("\nSCB Count = %d CMDS_PENDING = %d LASTSCB 0x%x "
8722 "CURRSCB 0x%x NEXTSCB 0x%x\n",
8723 ahd->scb_data.numscbs, ahd_inw(ahd, CMDS_PENDING),
8724 ahd_inw(ahd, LASTSCB), ahd_inw(ahd, CURRSCB),
8725 ahd_inw(ahd, NEXTSCB));
8726 cur_col = 0;
8727 /* QINFIFO */
8728 ahd_search_qinfifo(ahd, CAM_TARGET_WILDCARD, ALL_CHANNELS,
8729 CAM_LUN_WILDCARD, SCB_LIST_NULL,
8730 ROLE_UNKNOWN, /*status*/0, SEARCH_PRINT);
8731 saved_scb_index = ahd_get_scbptr(ahd);
8732 printf("Pending list:");
8733 i = 0;
8734 LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
8735 if (i++ > AHD_SCB_MAX)
8736 break;
8737 /*cur_col =*/ printf("\n%3d FIFO_USE[0x%x] ", SCB_GET_TAG(scb),
8738 ahd_inb_scbram(ahd, SCB_FIFO_USE_COUNT));
8739 ahd_set_scbptr(ahd, SCB_GET_TAG(scb));
8740 ahd_scb_control_print(ahd_inb_scbram(ahd, SCB_CONTROL),
8741 &cur_col, 60);
8742 ahd_scb_scsiid_print(ahd_inb_scbram(ahd, SCB_SCSIID),
8743 &cur_col, 60);
8744 }
8745 printf("\nTotal %d\n", i);
8746
8747 printf("Kernel Free SCB list: ");
8748 i = 0;
8749 TAILQ_FOREACH(scb, &ahd->scb_data.free_scbs, links.tqe) {
8750 struct scb *list_scb;
8751
8752 list_scb = scb;
8753 do {
8754 printf("%d ", SCB_GET_TAG(list_scb));
8755 list_scb = LIST_NEXT(list_scb, collision_links);
8756 } while (list_scb && i++ < AHD_SCB_MAX);
8757 }
8758
8759 LIST_FOREACH(scb, &ahd->scb_data.any_dev_free_scb_list, links.le) {
8760 if (i++ > AHD_SCB_MAX)
8761 break;
8762 printf("%d ", SCB_GET_TAG(scb));
8763 }
8764 printf("\n");
8765
8766 printf("Sequencer Complete DMA-inprog list: ");
8767 scb_index = ahd_inw(ahd, COMPLETE_SCB_DMAINPROG_HEAD);
8768 i = 0;
8769 while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
8770 ahd_set_scbptr(ahd, scb_index);
8771 printf("%d ", scb_index);
8772 scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
8773 }
8774 printf("\n");
8775
8776 printf("Sequencer Complete list: ");
8777 scb_index = ahd_inw(ahd, COMPLETE_SCB_HEAD);
8778 i = 0;
8779 while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
8780 ahd_set_scbptr(ahd, scb_index);
8781 printf("%d ", scb_index);
8782 scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
8783 }
8784 printf("\n");
8785
8786
8787 printf("Sequencer DMA-Up and Complete list: ");
8788 scb_index = ahd_inw(ahd, COMPLETE_DMA_SCB_HEAD);
8789 i = 0;
8790 while (!SCBID_IS_NULL(scb_index) && i++ < AHD_SCB_MAX) {
8791 ahd_set_scbptr(ahd, scb_index);
8792 printf("%d ", scb_index);
8793 scb_index = ahd_inw_scbram(ahd, SCB_NEXT_COMPLETE);
8794 }
8795 printf("\n");
8796 ahd_set_scbptr(ahd, saved_scb_index);
8797 dffstat = ahd_inb(ahd, DFFSTAT);
8798 for (i = 0; i < 2; i++) {
8799 #ifdef AHD_DEBUG
8800 struct scb *fifo_scb;
8801 #endif
8802 u_int fifo_scbptr;
8803
8804 ahd_set_modes(ahd, AHD_MODE_DFF0 + i, AHD_MODE_DFF0 + i);
8805 fifo_scbptr = ahd_get_scbptr(ahd);
8806 printf("\n%s: FIFO%d %s, LONGJMP == 0x%x, SCB 0x%x\n",
8807 ahd_name(ahd), i,
8808 (dffstat & (FIFO0FREE << i)) ? "Free" : "Active",
8809 ahd_inw(ahd, LONGJMP_ADDR), fifo_scbptr);
8810 cur_col = 0;
8811 ahd_seqimode_print(ahd_inb(ahd, SEQIMODE), &cur_col, 50);
8812 ahd_seqintsrc_print(ahd_inb(ahd, SEQINTSRC), &cur_col, 50);
8813 ahd_dfcntrl_print(ahd_inb(ahd, DFCNTRL), &cur_col, 50);
8814 ahd_dfstatus_print(ahd_inb(ahd, DFSTATUS), &cur_col, 50);
8815 ahd_sg_cache_shadow_print(ahd_inb(ahd, SG_CACHE_SHADOW),
8816 &cur_col, 50);
8817 ahd_sg_state_print(ahd_inb(ahd, SG_STATE), &cur_col, 50);
8818 ahd_dffsxfrctl_print(ahd_inb(ahd, DFFSXFRCTL), &cur_col, 50);
8819 ahd_soffcnt_print(ahd_inb(ahd, SOFFCNT), &cur_col, 50);
8820 ahd_mdffstat_print(ahd_inb(ahd, MDFFSTAT), &cur_col, 50);
8821 if (cur_col > 50) {
8822 printf("\n");
8823 cur_col = 0;
8824 }
8825 printf("\nSHADDR = 0x%x%x, SHCNT = 0x%x ",
8826 ahd_inl(ahd, SHADDR+4),
8827 ahd_inl(ahd, SHADDR),
8828 (ahd_inb(ahd, SHCNT)
8829 | (ahd_inb(ahd, SHCNT + 1) << 8)
8830 | (ahd_inb(ahd, SHCNT + 2) << 16)));
8831 printf("HADDR = 0x%x%x, HCNT = 0x%x \n",
8832 ahd_inl(ahd, HADDR+4),
8833 ahd_inl(ahd, HADDR),
8834 (ahd_inb(ahd, HCNT)
8835 | (ahd_inb(ahd, HCNT + 1) << 8)
8836 | (ahd_inb(ahd, HCNT + 2) << 16)));
8837 ahd_ccsgctl_print(ahd_inb(ahd, CCSGCTL), &cur_col, 50);
8838 #ifdef AHD_DEBUG
8839 if ((ahd_debug & AHD_SHOW_SG) != 0) {
8840 fifo_scb = ahd_lookup_scb(ahd, fifo_scbptr);
8841 if (fifo_scb != NULL)
8842 ahd_dump_sglist(fifo_scb);
8843 }
8844 #endif
8845 }
8846 printf("\nLQIN: ");
8847 for (i = 0; i < 20; i++)
8848 printf("0x%x ", ahd_inb(ahd, LQIN + i));
8849 printf("\n");
8850 ahd_set_modes(ahd, AHD_MODE_CFG, AHD_MODE_CFG);
8851 printf("%s: LQISTATE = 0x%x, LQOSTATE = 0x%x, OPTIONMODE = 0x%x\n",
8852 ahd_name(ahd), ahd_inb(ahd, LQISTATE), ahd_inb(ahd, LQOSTATE),
8853 ahd_inb(ahd, OPTIONMODE));
8854 printf("%s: OS_SPACE_CNT = 0x%x MAXCMDCNT = 0x%x\n",
8855 ahd_name(ahd), ahd_inb(ahd, OS_SPACE_CNT),
8856 ahd_inb(ahd, MAXCMDCNT));
8857 ahd_simode0_print(ahd_inb(ahd, SIMODE0), &cur_col, 50);
8858 printf("\n");
8859 ahd_set_modes(ahd, AHD_MODE_CCHAN, AHD_MODE_CCHAN);
8860 cur_col = 0;
8861 ahd_set_modes(ahd, ahd->saved_src_mode, ahd->saved_dst_mode);
8862 printf("%s: REG0 == 0x%x, SINDEX = 0x%x, DINDEX = 0x%x\n",
8863 ahd_name(ahd), ahd_inw(ahd, REG0), ahd_inw(ahd, SINDEX),
8864 ahd_inw(ahd, DINDEX));
8865 printf("%s: SCBPTR == 0x%x, SCB_NEXT == 0x%x, SCB_NEXT2 == 0x%x\n",
8866 ahd_name(ahd), ahd_get_scbptr(ahd),
8867 ahd_inw_scbram(ahd, SCB_NEXT),
8868 ahd_inw_scbram(ahd, SCB_NEXT2));
8869 printf("CDB %x %x %x %x %x %x\n",
8870 ahd_inb_scbram(ahd, SCB_CDB_STORE),
8871 ahd_inb_scbram(ahd, SCB_CDB_STORE+1),
8872 ahd_inb_scbram(ahd, SCB_CDB_STORE+2),
8873 ahd_inb_scbram(ahd, SCB_CDB_STORE+3),
8874 ahd_inb_scbram(ahd, SCB_CDB_STORE+4),
8875 ahd_inb_scbram(ahd, SCB_CDB_STORE+5));
8876 printf("STACK:");
8877 for (i = 0; i < ahd->stack_size; i++) {
8878 ahd->saved_stack[i] =
8879 ahd_inb(ahd, STACK)|(ahd_inb(ahd, STACK) << 8);
8880 printf(" 0x%x", ahd->saved_stack[i]);
8881 }
8882 for (i = ahd->stack_size-1; i >= 0; i--) {
8883 ahd_outb(ahd, STACK, ahd->saved_stack[i] & 0xFF);
8884 ahd_outb(ahd, STACK, (ahd->saved_stack[i] >> 8) & 0xFF);
8885 }
8886 printf("\n<<<<<<<<<<<<<<<<< Dump Card State Ends >>>>>>>>>>>>>>>>>>\n");
8887 ahd_platform_dump_card_state(ahd);
8888 ahd_restore_modes(ahd, saved_modes);
8889 if (paused == 0)
8890 ahd_unpause(ahd);
8891 }
8892
8893 void
8894 ahd_dump_scbs(struct ahd_softc *ahd)
8895 {
8896 ahd_mode_state saved_modes;
8897 u_int saved_scb_index;
8898 int i;
8899
8900 saved_modes = ahd_save_modes(ahd);
8901 ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
8902 saved_scb_index = ahd_get_scbptr(ahd);
8903 for (i = 0; i < AHD_SCB_MAX; i++) {
8904 ahd_set_scbptr(ahd, i);
8905 printf("%3d", i);
8906 printf("(CTRL 0x%x ID 0x%x N 0x%x N2 0x%x SG 0x%x, RSG 0x%x)\n",
8907 ahd_inb_scbram(ahd, SCB_CONTROL),
8908 ahd_inb_scbram(ahd, SCB_SCSIID),
8909 ahd_inw_scbram(ahd, SCB_NEXT),
8910 ahd_inw_scbram(ahd, SCB_NEXT2),
8911 ahd_inl_scbram(ahd, SCB_SGPTR),
8912 ahd_inl_scbram(ahd, SCB_RESIDUAL_SGPTR));
8913 }
8914 printf("\n");
8915 ahd_set_scbptr(ahd, saved_scb_index);
8916 ahd_restore_modes(ahd, saved_modes);
8917 }
8918
8919 /**************************** Flexport Logic **********************************/
8920 /*
8921 * Read count 16bit words from 16bit word address start_addr from the
8922 * SEEPROM attached to the controller, into tbuf, using the controller's
8923 * SEEPROM reading state machine. Optionally treat the data as a byte
8924 * stream in terms of byte order.
8925 */
8926 int
8927 ahd_read_seeprom(struct ahd_softc *ahd, uint16_t *tbuf,
8928 u_int start_addr, u_int count, int bytestream)
8929 {
8930 u_int cur_addr;
8931 u_int end_addr;
8932 int error;
8933
8934 /*
8935 * If we never make it through the loop even once,
8936 * we were passed invalid arguments.
8937 */
8938 error = EINVAL;
8939 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
8940 end_addr = start_addr + count;
8941 for (cur_addr = start_addr; cur_addr < end_addr; cur_addr++) {
8942
8943 ahd_outb(ahd, SEEADR, cur_addr);
8944 ahd_outb(ahd, SEECTL, SEEOP_READ | SEESTART);
8945
8946 error = ahd_wait_seeprom(ahd);
8947 if (error) {
8948 printf("%s: ahd_wait_seeprom timed out\n",
8949 ahd_name(ahd));
8950 break;
8951 }
8952 if (bytestream != 0) {
8953 uint8_t *bytestream_ptr;
8954
8955 bytestream_ptr = (uint8_t *)tbuf;
8956 *bytestream_ptr++ = ahd_inb(ahd, SEEDAT);
8957 *bytestream_ptr = ahd_inb(ahd, SEEDAT+1);
8958 } else {
8959 /*
8960 * ahd_inw() already handles machine byte order.
8961 */
8962 *tbuf = ahd_inw(ahd, SEEDAT);
8963 }
8964 tbuf++;
8965 }
8966 return (error);
8967 }
8968
8969 /*
8970 * Write count 16bit words from tbuf, into SEEPROM attache to the
8971 * controller starting at 16bit word address start_addr, using the
8972 * controller's SEEPROM writing state machine.
8973 */
8974 int
8975 ahd_write_seeprom(struct ahd_softc *ahd, uint16_t *tbuf,
8976 u_int start_addr, u_int count)
8977 {
8978 u_int cur_addr;
8979 u_int end_addr;
8980 int error;
8981 int retval;
8982
8983 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
8984 error = ENOENT;
8985
8986 /* Place the chip into write-enable mode */
8987 ahd_outb(ahd, SEEADR, SEEOP_EWEN_ADDR);
8988 ahd_outb(ahd, SEECTL, SEEOP_EWEN | SEESTART);
8989 error = ahd_wait_seeprom(ahd);
8990 if (error)
8991 return (error);
8992
8993 /*
8994 * Write the data. If we don't get throught the loop at
8995 * least once, the arguments were invalid.
8996 */
8997 retval = EINVAL;
8998 end_addr = start_addr + count;
8999 for (cur_addr = start_addr; cur_addr < end_addr; cur_addr++) {
9000 ahd_outw(ahd, SEEDAT, *tbuf++);
9001 ahd_outb(ahd, SEEADR, cur_addr);
9002 ahd_outb(ahd, SEECTL, SEEOP_WRITE | SEESTART);
9003
9004 retval = ahd_wait_seeprom(ahd);
9005 if (retval)
9006 break;
9007 }
9008
9009 /*
9010 * Disable writes.
9011 */
9012 ahd_outb(ahd, SEEADR, SEEOP_EWDS_ADDR);
9013 ahd_outb(ahd, SEECTL, SEEOP_EWDS | SEESTART);
9014 error = ahd_wait_seeprom(ahd);
9015 if (error)
9016 return (error);
9017 return (retval);
9018 }
9019
9020 /*
9021 * Wait ~100us for the serial eeprom to satisfy our request.
9022 */
9023 int
9024 ahd_wait_seeprom(struct ahd_softc *ahd)
9025 {
9026 int cnt;
9027
9028 cnt = 2000;
9029 while ((ahd_inb(ahd, SEESTAT) & (SEEARBACK|SEEBUSY)) != 0 && --cnt)
9030 ahd_delay(5);
9031
9032 if (cnt == 0)
9033 return (ETIMEDOUT);
9034 return (0);
9035 }
9036
9037 /*
9038 * Validate the two checksums in the per_channel
9039 * vital product data struct.
9040 */
9041 int
9042 ahd_verify_vpd_cksum(struct vpd_config *vpd)
9043 {
9044 int i;
9045 int maxaddr;
9046 uint32_t checksum;
9047 uint8_t *vpdarray;
9048
9049 vpdarray = (uint8_t *)vpd;
9050 maxaddr = offsetof(struct vpd_config, vpd_checksum);
9051 checksum = 0;
9052 for (i = offsetof(struct vpd_config, resource_type); i < maxaddr; i++)
9053 checksum = checksum + vpdarray[i];
9054 if (checksum == 0
9055 || (-checksum & 0xFF) != vpd->vpd_checksum)
9056 return (0);
9057
9058 checksum = 0;
9059 maxaddr = offsetof(struct vpd_config, checksum);
9060 for (i = offsetof(struct vpd_config, default_target_flags);
9061 i < maxaddr; i++)
9062 checksum = checksum + vpdarray[i];
9063 if (checksum == 0
9064 || (-checksum & 0xFF) != vpd->checksum)
9065 return (0);
9066 return (1);
9067 }
9068
9069 int
9070 ahd_verify_cksum(struct seeprom_config *sc)
9071 {
9072 int i;
9073 int maxaddr;
9074 uint32_t checksum;
9075 uint16_t *scarray;
9076
9077 maxaddr = (sizeof(*sc)/2) - 1;
9078 checksum = 0;
9079 scarray = (uint16_t *)sc;
9080
9081 for (i = 0; i < maxaddr; i++)
9082 checksum = checksum + scarray[i];
9083 if (checksum == 0
9084 || (checksum & 0xFFFF) != sc->checksum) {
9085 return (0);
9086 } else {
9087 return (1);
9088 }
9089 }
9090
9091 int
9092 ahd_acquire_seeprom(struct ahd_softc *ahd)
9093 {
9094 /*
9095 * We should be able to determine the SEEPROM type
9096 * from the flexport logic, but unfortunately not
9097 * all implementations have this logic and there is
9098 * no programatic method for determining if the logic
9099 * is present.
9100 */
9101
9102 return (1);
9103 #if 0
9104 uint8_t seetype;
9105 int error;
9106
9107 error = ahd_read_flexport(ahd, FLXADDR_ROMSTAT_CURSENSECTL, &seetype);
9108 if (error != 0
9109 || ((seetype & FLX_ROMSTAT_SEECFG) == FLX_ROMSTAT_SEE_NONE))
9110 return (0);
9111 return (1);
9112 #endif
9113 }
9114
9115 void
9116 ahd_release_seeprom(struct ahd_softc *ahd)
9117 {
9118 /* Currently a no-op */
9119 }
9120
9121 int
9122 ahd_write_flexport(struct ahd_softc *ahd, u_int addr, u_int value)
9123 {
9124 int error;
9125
9126 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
9127 if (addr > 7)
9128 panic("ahd_write_flexport: address out of range");
9129 ahd_outb(ahd, BRDCTL, BRDEN|(addr << 3));
9130 error = ahd_wait_flexport(ahd);
9131 if (error != 0)
9132 return (error);
9133 ahd_outb(ahd, BRDDAT, value);
9134 ahd_flush_device_writes(ahd);
9135 ahd_outb(ahd, BRDCTL, BRDSTB|BRDEN|(addr << 3));
9136 ahd_flush_device_writes(ahd);
9137 ahd_outb(ahd, BRDCTL, BRDEN|(addr << 3));
9138 ahd_flush_device_writes(ahd);
9139 ahd_outb(ahd, BRDCTL, 0);
9140 ahd_flush_device_writes(ahd);
9141 return (0);
9142 }
9143
9144 int
9145 ahd_read_flexport(struct ahd_softc *ahd, u_int addr, uint8_t *value)
9146 {
9147 int error;
9148
9149 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
9150 if (addr > 7)
9151 panic("ahd_read_flexport: address out of range");
9152 ahd_outb(ahd, BRDCTL, BRDRW|BRDEN|(addr << 3));
9153 error = ahd_wait_flexport(ahd);
9154 if (error != 0)
9155 return (error);
9156 *value = ahd_inb(ahd, BRDDAT);
9157 ahd_outb(ahd, BRDCTL, 0);
9158 ahd_flush_device_writes(ahd);
9159 return (0);
9160 }
9161
9162 /*
9163 * Wait at most 2 seconds for flexport arbitration to succeed.
9164 */
9165 int
9166 ahd_wait_flexport(struct ahd_softc *ahd)
9167 {
9168 int cnt;
9169
9170 AHD_ASSERT_MODES(ahd, AHD_MODE_SCSI_MSK, AHD_MODE_SCSI_MSK);
9171 cnt = 1000000 * 2 / 5;
9172 while ((ahd_inb(ahd, BRDCTL) & FLXARBACK) == 0 && --cnt)
9173 ahd_delay(5);
9174
9175 if (cnt == 0)
9176 return (ETIMEDOUT);
9177 return (0);
9178 }
9179
9180 /************************* Target Mode ****************************************/
9181 #ifdef AHD_TARGET_MODE
9182 cam_status
9183 ahd_find_tmode_devs(struct ahd_softc *ahd, struct cam_sim *sim, union ccb *ccb,
9184 struct ahd_tmode_tstate **tstate,
9185 struct ahd_tmode_lstate **lstate,
9186 int notfound_failure)
9187 {
9188
9189 if ((ahd->features & AHD_TARGETMODE) == 0)
9190 return (CAM_REQ_INVALID);
9191
9192 /*
9193 * Handle the 'black hole' device that sucks up
9194 * requests to unattached luns on enabled targets.
9195 */
9196 if (ccb->ccb_h.target_id == CAM_TARGET_WILDCARD
9197 && ccb->ccb_h.target_lun == CAM_LUN_WILDCARD) {
9198 *tstate = NULL;
9199 *lstate = ahd->black_hole;
9200 } else {
9201 u_int max_id;
9202
9203 max_id = (ahd->features & AHD_WIDE) ? 15 : 7;
9204 if (ccb->ccb_h.target_id > max_id)
9205 return (CAM_TID_INVALID);
9206
9207 if (ccb->ccb_h.target_lun >= AHD_NUM_LUNS)
9208 return (CAM_LUN_INVALID);
9209
9210 *tstate = ahd->enabled_targets[ccb->ccb_h.target_id];
9211 *lstate = NULL;
9212 if (*tstate != NULL)
9213 *lstate =
9214 (*tstate)->enabled_luns[ccb->ccb_h.target_lun];
9215 }
9216
9217 if (notfound_failure != 0 && *lstate == NULL)
9218 return (CAM_PATH_INVALID);
9219
9220 return (CAM_REQ_CMP);
9221 }
9222
9223 void
9224 ahd_handle_en_lun(struct ahd_softc *ahd, struct cam_sim *sim, union ccb *ccb)
9225 {
9226 #if NOT_YET
9227 struct ahd_tmode_tstate *tstate;
9228 struct ahd_tmode_lstate *lstate;
9229 struct ccb_en_lun *cel;
9230 cam_status status;
9231 u_int target;
9232 u_int lun;
9233 u_int target_mask;
9234 u_long s;
9235 char channel;
9236
9237 status = ahd_find_tmode_devs(ahd, sim, ccb, &tstate, &lstate,
9238 /*notfound_failure*/FALSE);
9239
9240 if (status != CAM_REQ_CMP) {
9241 ccb->ccb_h.status = status;
9242 return;
9243 }
9244
9245 if ((ahd->features & AHD_MULTIROLE) != 0) {
9246 u_int our_id;
9247
9248 our_id = ahd->our_id;
9249 if (ccb->ccb_h.target_id != our_id) {
9250 if ((ahd->features & AHD_MULTI_TID) != 0
9251 && (ahd->flags & AHD_INITIATORROLE) != 0) {
9252 /*
9253 * Only allow additional targets if
9254 * the initiator role is disabled.
9255 * The hardware cannot handle a re-select-in
9256 * on the initiator id during a re-select-out
9257 * on a different target id.
9258 */
9259 status = CAM_TID_INVALID;
9260 } else if ((ahd->flags & AHD_INITIATORROLE) != 0
9261 || ahd->enabled_luns > 0) {
9262 /*
9263 * Only allow our target id to change
9264 * if the initiator role is not configured
9265 * and there are no enabled luns which
9266 * are attached to the currently registered
9267 * scsi id.
9268 */
9269 status = CAM_TID_INVALID;
9270 }
9271 }
9272 }
9273
9274 if (status != CAM_REQ_CMP) {
9275 ccb->ccb_h.status = status;
9276 return;
9277 }
9278
9279 /*
9280 * We now have an id that is valid.
9281 * If we aren't in target mode, switch modes.
9282 */
9283 if ((ahd->flags & AHD_TARGETROLE) == 0
9284 && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) {
9285 u_long s;
9286
9287 printf("Configuring Target Mode\n");
9288 ahd_lock(ahd, &s);
9289 if (LIST_FIRST(&ahd->pending_scbs) != NULL) {
9290 ccb->ccb_h.status = CAM_BUSY;
9291 ahd_unlock(ahd, &s);
9292 return;
9293 }
9294 ahd->flags |= AHD_TARGETROLE;
9295 if ((ahd->features & AHD_MULTIROLE) == 0)
9296 ahd->flags &= ~AHD_INITIATORROLE;
9297 ahd_pause(ahd);
9298 ahd_loadseq(ahd);
9299 ahd_restart(ahd);
9300 ahd_unlock(ahd, &s);
9301 }
9302 cel = &ccb->cel;
9303 target = ccb->ccb_h.target_id;
9304 lun = ccb->ccb_h.target_lun;
9305 channel = SIM_CHANNEL(ahd, sim);
9306 target_mask = 0x01 << target;
9307 if (channel == 'B')
9308 target_mask <<= 8;
9309
9310 if (cel->enable != 0) {
9311 u_int scsiseq1;
9312
9313 /* Are we already enabled?? */
9314 if (lstate != NULL) {
9315 xpt_print_path(ccb->ccb_h.path);
9316 printf("Lun already enabled\n");
9317 ccb->ccb_h.status = CAM_LUN_ALRDY_ENA;
9318 return;
9319 }
9320
9321 if (cel->grp6_len != 0
9322 || cel->grp7_len != 0) {
9323 /*
9324 * Don't (yet?) support vendor
9325 * specific commands.
9326 */
9327 ccb->ccb_h.status = CAM_REQ_INVALID;
9328 printf("Non-zero Group Codes\n");
9329 return;
9330 }
9331
9332 /*
9333 * Seems to be okay.
9334 * Setup our data structures.
9335 */
9336 if (target != CAM_TARGET_WILDCARD && tstate == NULL) {
9337 tstate = ahd_alloc_tstate(ahd, target, channel);
9338 if (tstate == NULL) {
9339 xpt_print_path(ccb->ccb_h.path);
9340 printf("Couldn't allocate tstate\n");
9341 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
9342 return;
9343 }
9344 }
9345 lstate = malloc(sizeof(*lstate), M_DEVBUF, M_NOWAIT);
9346 if (lstate == NULL) {
9347 xpt_print_path(ccb->ccb_h.path);
9348 printf("Couldn't allocate lstate\n");
9349 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
9350 return;
9351 }
9352 memset(lstate, 0, sizeof(*lstate));
9353 status = xpt_create_path(&lstate->path, /*periph*/NULL,
9354 xpt_path_path_id(ccb->ccb_h.path),
9355 xpt_path_target_id(ccb->ccb_h.path),
9356 xpt_path_lun_id(ccb->ccb_h.path));
9357 if (status != CAM_REQ_CMP) {
9358 free(lstate, M_DEVBUF);
9359 xpt_print_path(ccb->ccb_h.path);
9360 printf("Couldn't allocate path\n");
9361 ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
9362 return;
9363 }
9364 SLIST_INIT(&lstate->accept_tios);
9365 SLIST_INIT(&lstate->immed_notifies);
9366 ahd_lock(ahd, &s);
9367 ahd_pause(ahd);
9368 if (target != CAM_TARGET_WILDCARD) {
9369 tstate->enabled_luns[lun] = lstate;
9370 ahd->enabled_luns++;
9371
9372 if ((ahd->features & AHD_MULTI_TID) != 0) {
9373 u_int targid_mask;
9374
9375 targid_mask = ahd_inb(ahd, TARGID)
9376 | (ahd_inb(ahd, TARGID + 1) << 8);
9377
9378 targid_mask |= target_mask;
9379 ahd_outb(ahd, TARGID, targid_mask);
9380 ahd_outb(ahd, TARGID+1, (targid_mask >> 8));
9381
9382 ahd_update_scsiid(ahd, targid_mask);
9383 } else {
9384 u_int our_id;
9385 char channel;
9386
9387 channel = SIM_CHANNEL(ahd, sim);
9388 our_id = SIM_SCSI_ID(ahd, sim);
9389
9390 /*
9391 * This can only happen if selections
9392 * are not enabled
9393 */
9394 if (target != our_id) {
9395 u_int sblkctl;
9396 char cur_channel;
9397 int swap;
9398
9399 sblkctl = ahd_inb(ahd, SBLKCTL);
9400 cur_channel = (sblkctl & SELBUSB)
9401 ? 'B' : 'A';
9402 if ((ahd->features & AHD_TWIN) == 0)
9403 cur_channel = 'A';
9404 swap = cur_channel != channel;
9405 ahd->our_id = target;
9406
9407 if (swap)
9408 ahd_outb(ahd, SBLKCTL,
9409 sblkctl ^ SELBUSB);
9410
9411 ahd_outb(ahd, SCSIID, target);
9412
9413 if (swap)
9414 ahd_outb(ahd, SBLKCTL, sblkctl);
9415 }
9416 }
9417 } else
9418 ahd->black_hole = lstate;
9419 /* Allow select-in operations */
9420 if (ahd->black_hole != NULL && ahd->enabled_luns > 0) {
9421 scsiseq1 = ahd_inb(ahd, SCSISEQ_TEMPLATE);
9422 scsiseq1 |= ENSELI;
9423 ahd_outb(ahd, SCSISEQ_TEMPLATE, scsiseq1);
9424 scsiseq1 = ahd_inb(ahd, SCSISEQ1);
9425 scsiseq1 |= ENSELI;
9426 ahd_outb(ahd, SCSISEQ1, scsiseq1);
9427 }
9428 ahd_unpause(ahd);
9429 ahd_unlock(ahd, &s);
9430 ccb->ccb_h.status = CAM_REQ_CMP;
9431 xpt_print_path(ccb->ccb_h.path);
9432 printf("Lun now enabled for target mode\n");
9433 } else {
9434 struct scb *scb;
9435 int i, empty;
9436
9437 if (lstate == NULL) {
9438 ccb->ccb_h.status = CAM_LUN_INVALID;
9439 return;
9440 }
9441
9442 ahd_lock(ahd, &s);
9443
9444 ccb->ccb_h.status = CAM_REQ_CMP;
9445 LIST_FOREACH(scb, &ahd->pending_scbs, pending_links) {
9446 struct ccb_hdr *ccbh;
9447
9448 ccbh = &scb->io_ctx->ccb_h;
9449 if (ccbh->func_code == XPT_CONT_TARGET_IO
9450 && !xpt_path_comp(ccbh->path, ccb->ccb_h.path)){
9451 printf("CTIO pending\n");
9452 ccb->ccb_h.status = CAM_REQ_INVALID;
9453 ahd_unlock(ahd, &s);
9454 return;
9455 }
9456 }
9457
9458 if (SLIST_FIRST(&lstate->accept_tios) != NULL) {
9459 printf("ATIOs pending\n");
9460 ccb->ccb_h.status = CAM_REQ_INVALID;
9461 }
9462
9463 if (SLIST_FIRST(&lstate->immed_notifies) != NULL) {
9464 printf("INOTs pending\n");
9465 ccb->ccb_h.status = CAM_REQ_INVALID;
9466 }
9467
9468 if (ccb->ccb_h.status != CAM_REQ_CMP) {
9469 ahd_unlock(ahd, &s);
9470 return;
9471 }
9472
9473 xpt_print_path(ccb->ccb_h.path);
9474 printf("Target mode disabled\n");
9475 xpt_free_path(lstate->path);
9476 free(lstate, M_DEVBUF);
9477
9478 ahd_pause(ahd);
9479 /* Can we clean up the target too? */
9480 if (target != CAM_TARGET_WILDCARD) {
9481 tstate->enabled_luns[lun] = NULL;
9482 ahd->enabled_luns--;
9483 for (empty = 1, i = 0; i < 8; i++)
9484 if (tstate->enabled_luns[i] != NULL) {
9485 empty = 0;
9486 break;
9487 }
9488
9489 if (empty) {
9490 ahd_free_tstate(ahd, target, channel,
9491 /*force*/FALSE);
9492 if (ahd->features & AHD_MULTI_TID) {
9493 u_int targid_mask;
9494
9495 targid_mask = ahd_inb(ahd, TARGID)
9496 | (ahd_inb(ahd, TARGID + 1)
9497 << 8);
9498
9499 targid_mask &= ~target_mask;
9500 ahd_outb(ahd, TARGID, targid_mask);
9501 ahd_outb(ahd, TARGID+1,
9502 (targid_mask >> 8));
9503 ahd_update_scsiid(ahd, targid_mask);
9504 }
9505 }
9506 } else {
9507
9508 ahd->black_hole = NULL;
9509
9510 /*
9511 * We can't allow selections without
9512 * our black hole device.
9513 */
9514 empty = TRUE;
9515 }
9516 if (ahd->enabled_luns == 0) {
9517 /* Disallow select-in */
9518 u_int scsiseq1;
9519
9520 scsiseq1 = ahd_inb(ahd, SCSISEQ_TEMPLATE);
9521 scsiseq1 &= ~ENSELI;
9522 ahd_outb(ahd, SCSISEQ_TEMPLATE, scsiseq1);
9523 scsiseq1 = ahd_inb(ahd, SCSISEQ1);
9524 scsiseq1 &= ~ENSELI;
9525 ahd_outb(ahd, SCSISEQ1, scsiseq1);
9526
9527 if ((ahd->features & AHD_MULTIROLE) == 0) {
9528 printf("Configuring Initiator Mode\n");
9529 ahd->flags &= ~AHD_TARGETROLE;
9530 ahd->flags |= AHD_INITIATORROLE;
9531 ahd_pause(ahd);
9532 ahd_loadseq(ahd);
9533 ahd_restart(ahd);
9534 /*
9535 * Unpaused. The extra unpause
9536 * that follows is harmless.
9537 */
9538 }
9539 }
9540 ahd_unpause(ahd);
9541 ahd_unlock(ahd, &s);
9542 }
9543 #endif
9544 }
9545
9546 static void
9547 ahd_update_scsiid(struct ahd_softc *ahd, u_int targid_mask)
9548 {
9549 #if NOT_YET
9550 u_int scsiid_mask;
9551 u_int scsiid;
9552
9553 if ((ahd->features & AHD_MULTI_TID) == 0)
9554 panic("ahd_update_scsiid called on non-multitid unit\n");
9555
9556 /*
9557 * Since we will rely on the TARGID mask
9558 * for selection enables, ensure that OID
9559 * in SCSIID is not set to some other ID
9560 * that we don't want to allow selections on.
9561 */
9562 if ((ahd->features & AHD_ULTRA2) != 0)
9563 scsiid = ahd_inb(ahd, SCSIID_ULTRA2);
9564 else
9565 scsiid = ahd_inb(ahd, SCSIID);
9566 scsiid_mask = 0x1 << (scsiid & OID);
9567 if ((targid_mask & scsiid_mask) == 0) {
9568 u_int our_id;
9569
9570 /* ffs counts from 1 */
9571 our_id = ffs(targid_mask);
9572 if (our_id == 0)
9573 our_id = ahd->our_id;
9574 else
9575 our_id--;
9576 scsiid &= TID;
9577 scsiid |= our_id;
9578 }
9579 if ((ahd->features & AHD_ULTRA2) != 0)
9580 ahd_outb(ahd, SCSIID_ULTRA2, scsiid);
9581 else
9582 ahd_outb(ahd, SCSIID, scsiid);
9583 #endif
9584 }
9585
9586 #ifdef AHD_TARGET_MODE
9587 void
9588 ahd_run_tqinfifo(struct ahd_softc *ahd, int paused)
9589 {
9590 struct target_cmd *cmd;
9591
9592 ahd_sync_tqinfifo(ahd, BUS_DMASYNC_POSTREAD);
9593 while ((cmd = &ahd->targetcmds[ahd->tqinfifonext])->cmd_valid != 0) {
9594
9595 /*
9596 * Only advance through the queue if we
9597 * have the resources to process the command.
9598 */
9599 if (ahd_handle_target_cmd(ahd, cmd) != 0)
9600 break;
9601
9602 cmd->cmd_valid = 0;
9603 ahd_dmamap_sync(ahd, ahd->parent_dmat /*shared_data_dmat*/,
9604 ahd->shared_data_map.dmamap,
9605 ahd_targetcmd_offset(ahd, ahd->tqinfifonext),
9606 sizeof(struct target_cmd),
9607 BUS_DMASYNC_PREREAD);
9608 ahd->tqinfifonext++;
9609
9610 /*
9611 * Lazily update our position in the target mode incoming
9612 * command queue as seen by the sequencer.
9613 */
9614 if ((ahd->tqinfifonext & (HOST_TQINPOS - 1)) == 1) {
9615 u_int hs_mailbox;
9616
9617 hs_mailbox = ahd_inb(ahd, HS_MAILBOX);
9618 hs_mailbox &= ~HOST_TQINPOS;
9619 hs_mailbox |= ahd->tqinfifonext & HOST_TQINPOS;
9620 ahd_outb(ahd, HS_MAILBOX, hs_mailbox);
9621 }
9622 }
9623 }
9624 #endif
9625
9626 static int
9627 ahd_handle_target_cmd(struct ahd_softc *ahd, struct target_cmd *cmd)
9628 {
9629 struct ahd_tmode_tstate *tstate;
9630 struct ahd_tmode_lstate *lstate;
9631 struct ccb_accept_tio *atio;
9632 uint8_t *byte;
9633 int initiator;
9634 int target;
9635 int lun;
9636
9637 initiator = SCSIID_TARGET(ahd, cmd->scsiid);
9638 target = SCSIID_OUR_ID(cmd->scsiid);
9639 lun = (cmd->identify & MSG_IDENTIFY_LUNMASK);
9640
9641 byte = cmd->bytes;
9642 tstate = ahd->enabled_targets[target];
9643 lstate = NULL;
9644 if (tstate != NULL)
9645 lstate = tstate->enabled_luns[lun];
9646
9647 /*
9648 * Commands for disabled luns go to the black hole driver.
9649 */
9650 if (lstate == NULL)
9651 lstate = ahd->black_hole;
9652
9653 atio = (struct ccb_accept_tio*)SLIST_FIRST(&lstate->accept_tios);
9654 if (atio == NULL) {
9655 ahd->flags |= AHD_TQINFIFO_BLOCKED;
9656 /*
9657 * Wait for more ATIOs from the peripheral driver for this lun.
9658 */
9659 return (1);
9660 } else
9661 ahd->flags &= ~AHD_TQINFIFO_BLOCKED;
9662 #ifdef AHD_DEBUG
9663 if ((ahd_debug & AHD_SHOW_TQIN) != 0)
9664 printf("%s: incoming command from %d for %d:%d%s\n",
9665 ahd_name(ahd),
9666 initiator, target, lun,
9667 lstate == ahd->black_hole ? "(Black Holed)" : "");
9668 #endif
9669 SLIST_REMOVE_HEAD(&lstate->accept_tios, sim_links.sle);
9670
9671 if (lstate == ahd->black_hole) {
9672 /* Fill in the wildcards */
9673 atio->ccb_h.target_id = target;
9674 atio->ccb_h.target_lun = lun;
9675 }
9676
9677 /*
9678 * Package it up and send it off to
9679 * whomever has this lun enabled.
9680 */
9681 atio->sense_len = 0;
9682 atio->init_id = initiator;
9683 if (byte[0] != 0xFF) {
9684 /* Tag was included */
9685 atio->tag_action = *byte++;
9686 atio->tag_id = *byte++;
9687 atio->ccb_h.flags = CAM_TAG_ACTION_VALID;
9688 } else {
9689 atio->ccb_h.flags = 0;
9690 }
9691 byte++;
9692
9693 /* Okay. Now determine the cdb size based on the command code */
9694 switch (*byte >> CMD_GROUP_CODE_SHIFT) {
9695 case 0:
9696 atio->cdb_len = 6;
9697 break;
9698 case 1:
9699 case 2:
9700 atio->cdb_len = 10;
9701 break;
9702 case 4:
9703 atio->cdb_len = 16;
9704 break;
9705 case 5:
9706 atio->cdb_len = 12;
9707 break;
9708 case 3:
9709 default:
9710 /* Only copy the opcode. */
9711 atio->cdb_len = 1;
9712 printf("Reserved or VU command code type encountered\n");
9713 break;
9714 }
9715
9716 memcpy(atio->cdb_io.cdb_bytes, byte, atio->cdb_len);
9717
9718 atio->ccb_h.status |= CAM_CDB_RECVD;
9719
9720 if ((cmd->identify & MSG_IDENTIFY_DISCFLAG) == 0) {
9721 /*
9722 * We weren't allowed to disconnect.
9723 * We're hanging on the bus until a
9724 * continue target I/O comes in response
9725 * to this accept tio.
9726 */
9727 #ifdef AHD_DEBUG
9728 if ((ahd_debug & AHD_SHOW_TQIN) != 0)
9729 printf("Received Immediate Command %d:%d:%d - %p\n",
9730 initiator, target, lun, ahd->pending_device);
9731 #endif
9732 ahd->pending_device = lstate;
9733 ahd_freeze_ccb((union ccb *)atio);
9734 atio->ccb_h.flags |= CAM_DIS_DISCONNECT;
9735 }
9736 xpt_done((union ccb*)atio);
9737 return (0);
9738 }
9739
9740 #endif
9741
9742 static int
9743 ahd_createdmamem(bus_dma_tag_t tag, int size, int flags, bus_dmamap_t *mapp,
9744 void **vaddr, bus_addr_t *baddr, bus_dma_segment_t *seg, int *nseg,
9745 const char *myname, const char *what)
9746 {
9747 int error, level = 0;
9748
9749 if ((error = bus_dmamem_alloc(tag, size, PAGE_SIZE, 0,
9750 seg, 1, nseg, BUS_DMA_WAITOK)) != 0) {
9751 printf("%s: failed to allocate DMA mem for %s, error = %d\n",
9752 myname, what, error);
9753 goto out;
9754 }
9755 level++;
9756
9757 if ((error = bus_dmamem_map(tag, seg, *nseg, size, vaddr,
9758 BUS_DMA_WAITOK|BUS_DMA_COHERENT)) != 0) {
9759 printf("%s: failed to map DMA mem for %s, error = %d\n",
9760 myname, what, error);
9761 goto out;
9762 }
9763 level++;
9764
9765 if ((error = bus_dmamap_create(tag, size, 1, size, 0,
9766 BUS_DMA_WAITOK | flags, mapp)) != 0) {
9767 printf("%s: failed to create DMA map for %s, error = %d\n",
9768 myname, what, error);
9769 goto out;
9770 }
9771 level++;
9772
9773
9774 if ((error = bus_dmamap_load(tag, *mapp, *vaddr, size, NULL,
9775 BUS_DMA_WAITOK)) != 0) {
9776 printf("%s: failed to load DMA map for %s, error = %d\n",
9777 myname, what, error);
9778 goto out;
9779 }
9780
9781 *baddr = (*mapp)->dm_segs[0].ds_addr;
9782
9783 return 0;
9784 out:
9785 printf("ahd_createdmamem error (%d)\n", level);
9786 switch (level) {
9787 case 3:
9788 bus_dmamap_destroy(tag, *mapp);
9789 /* FALLTHROUGH */
9790 case 2:
9791 bus_dmamem_unmap(tag, *vaddr, size);
9792 /* FALLTHROUGH */
9793 case 1:
9794 bus_dmamem_free(tag, seg, *nseg);
9795 break;
9796 default:
9797 break;
9798 }
9799
9800 return error;
9801 }
9802
9803 static void
9804 ahd_freedmamem(bus_dma_tag_t tag, int size, bus_dmamap_t map, void *vaddr,
9805 bus_dma_segment_t *seg, int nseg)
9806 {
9807
9808 bus_dmamap_unload(tag, map);
9809 bus_dmamap_destroy(tag, map);
9810 bus_dmamem_unmap(tag, vaddr, size);
9811 bus_dmamem_free(tag, seg, nseg);
9812 }
NetBSD on the FriendlyARM MINI2440