?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / arch / acorn32 / podulebus / esc.c
blobfe591ebb986674b705d361319379c34b23eec670
1 /* $NetBSD: esc.c,v 1.22 2009/03/18 17:06:41 cegger Exp $ */
2
3 /*
4 * Copyright (c) 1990 The Regents of the University of California.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Van Jacobson of Lawrence Berkeley Laboratory.
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 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)scsi.c 7.5 (Berkeley) 5/4/91
35 */
36
37 /*
38 * Copyright (c) 1995 Scott Stevens
39 * Copyright (c) 1995 Daniel Widenfalk
40 * Copyright (c) 1994 Christian E. Hopps
41 *
42 * This code is derived from software contributed to Berkeley by
43 * Van Jacobson of Lawrence Berkeley Laboratory.
44 *
45 * Redistribution and use in source and binary forms, with or without
46 * modification, are permitted provided that the following conditions
47 * are met:
48 * 1. Redistributions of source code must retain the above copyright
49 * notice, this list of conditions and the following disclaimer.
50 * 2. Redistributions in binary form must reproduce the above copyright
51 * notice, this list of conditions and the following disclaimer in the
52 * documentation and/or other materials provided with the distribution.
53 * 3. All advertising materials mentioning features or use of this software
54 * must display the following acknowledgement:
55 * This product includes software developed by the University of
56 * California, Berkeley and its contributors.
57 * 4. Neither the name of the University nor the names of its contributors
58 * may be used to endorse or promote products derived from this software
59 * without specific prior written permission.
60 *
61 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
62 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
64 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
69 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
70 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
71 * SUCH DAMAGE.
72 *
73 * @(#)scsi.c 7.5 (Berkeley) 5/4/91
74 */
75
76 /*
77 * AMD AM53CF94 scsi adaptor driver
78 *
79 * Functionally compatible with the FAS216
80 *
81 * Apart from a very small patch to set up control register 4
82 */
83
84 /*
85 * Modified for NetBSD/arm32 by Scott Stevens
86 */
87
88 #include <sys/cdefs.h>
89 __KERNEL_RCSID(0, "$NetBSD: esc.c,v 1.22 2009/03/18 17:06:41 cegger Exp $");
90
91 #include <sys/param.h>
92 #include <sys/systm.h>
93 #include <sys/device.h>
94 #include <sys/buf.h>
95 #include <sys/proc.h>
96 #include <dev/scsipi/scsi_all.h>
97 #include <dev/scsipi/scsipi_all.h>
98 #include <dev/scsipi/scsiconf.h>
99
100 #include <uvm/uvm_extern.h>
101
102 #include <machine/pmap.h>
103 #include <machine/cpu.h>
104 #include <machine/io.h>
105 #include <machine/intr.h>
106 #include <arm/arm32/katelib.h>
107 #include <acorn32/podulebus/podulebus.h>
108 #include <acorn32/podulebus/escreg.h>
109 #include <acorn32/podulebus/escvar.h>
110
111 void escinitialize(struct esc_softc *);
112 void esc_minphys(struct buf *bp);
113 void esc_scsi_request(struct scsipi_channel *,
114 scsipi_adapter_req_t, void *);
115 void esc_donextcmd(struct esc_softc *dev, struct esc_pending *pendp);
116 void esc_scsidone(struct esc_softc *dev, struct scsipi_xfer *xs,
117 int stat);
118 void escintr(struct esc_softc *dev);
119 void esciwait(struct esc_softc *dev);
120 void escreset(struct esc_softc *dev, int how);
121 int escselect(struct esc_softc *dev, struct esc_pending *pendp,
122 unsigned char *cbuf, int clen,
123 unsigned char *buf, int len, int mode);
124 void escicmd(struct esc_softc *dev, struct esc_pending *pendp);
125 int escgo(struct esc_softc *dev, struct esc_pending *pendp);
126
127 void esc_init_nexus(struct esc_softc *, struct nexus *);
128 void esc_save_pointers(struct esc_softc *);
129 void esc_restore_pointers(struct esc_softc *);
130 void esc_ixfer(struct esc_softc *);
131 void esc_build_sdtrm(struct esc_softc *, int, int);
132 int esc_select_unit(struct esc_softc *, short);
133 struct nexus *esc_arbitate_target(struct esc_softc *, int);
134 void esc_setup_nexus(struct esc_softc *, struct nexus *, struct esc_pending *,
135 unsigned char *, int, unsigned char *, int, int);
136 int esc_pretests(struct esc_softc *, esc_regmap_p);
137 int esc_midaction(struct esc_softc *, esc_regmap_p, struct nexus *);
138 int esc_postaction(struct esc_softc *, esc_regmap_p, struct nexus *);
139
140
141 /*
142 * Initialize these to make 'em patchable. Defaults to enable sync and discon.
143 */
144 u_char esc_inhibit_sync[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
145 u_char esc_inhibit_disc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
146
147 #define DEBUG
148 #ifdef DEBUG
149 #define QPRINTF(a) if (esc_debug > 1) printf a
150 int esc_debug = 2;
151 #else
152 #define QPRINTF
153 #endif
154
155 /*
156 * default minphys routine for esc based controllers
157 */
158 void
159 esc_minphys(struct buf *bp)
160 {
161
162 /*
163 * No max transfer at this level.
164 */
165 minphys(bp);
166 }
167
168 /*
169 * Initialize the nexus structs.
170 */
171 void
172 esc_init_nexus(struct esc_softc *dev, struct nexus *nexus)
173 {
174 memset(nexus, 0, sizeof(struct nexus));
175
176 nexus->state = ESC_NS_IDLE;
177 nexus->period = 200;
178 nexus->offset = 0;
179 nexus->syncper = 5;
180 nexus->syncoff = 0;
181 nexus->config3 = dev->sc_config3 & ~ESC_CFG3_FASTSCSI;
182 }
183
184 void
185 escinitialize(struct esc_softc *dev)
186 {
187 u_int *pte;
188 int i;
189
190 dev->sc_led_status = 0;
191
192 TAILQ_INIT(&dev->sc_xs_pending);
193 TAILQ_INIT(&dev->sc_xs_free);
194
195 /*
196 * Initialize the esc_pending structs and link them into the free list. We
197 * have to set vm_link_data.pages to 0 or the vm FIX won't work.
198 */
199 for(i=0; i<MAXPENDING; i++) {
200 TAILQ_INSERT_TAIL(&dev->sc_xs_free, &dev->sc_xs_store[i],
201 link);
202 }
203
204 /*
205 * Calculate the correct clock conversion factor 2 <= factor <= 8, i.e. set
206 * the factor to clock_freq / 5 (int).
207 */
208 if (dev->sc_clock_freq <= 10)
209 dev->sc_clock_conv_fact = 2;
210 if (dev->sc_clock_freq <= 40)
211 dev->sc_clock_conv_fact = 2+((dev->sc_clock_freq-10)/5);
212 else
213 panic("escinitialize: Clock frequence too high");
214
215 /* Setup and save the basic configuration registers */
216 dev->sc_config1 = (dev->sc_host_id & ESC_CFG1_BUS_ID_MASK);
217 dev->sc_config2 = ESC_CFG2_FEATURES_ENABLE;
218 dev->sc_config3 = (dev->sc_clock_freq > 25 ? ESC_CFG3_FASTCLK : 0);
219
220 /* Precalculate timeout value and clock period. */
221 /* Ekkk ... floating point in the kernel !!!! */
222 /* dev->sc_timeout_val = 1+dev->sc_timeout*dev->sc_clock_freq/
223 (7.682*dev->sc_clock_conv_fact);*/
224 dev->sc_timeout_val = 1+dev->sc_timeout*dev->sc_clock_freq/
225 ((7682*dev->sc_clock_conv_fact)/1000);
226 dev->sc_clock_period = 1000/dev->sc_clock_freq;
227
228 escreset(dev, 1 | 2); /* Reset Chip and Bus */
229
230 dev->sc_units_disconnected = 0;
231 dev->sc_msg_in_len = 0;
232 dev->sc_msg_out_len = 0;
233
234 dev->sc_flags = 0;
235
236 for(i=0; i<8; i++)
237 esc_init_nexus(dev, &dev->sc_nexus[i]);
238
239 /*
240 * Setup bump buffer.
241 */
242 dev->sc_bump_va = (u_char *)uvm_km_alloc(kernel_map, dev->sc_bump_sz, 0,
243 UVM_KMF_WIRED | UVM_KMF_ZERO);
244 (void) pmap_extract(pmap_kernel(), (vaddr_t)dev->sc_bump_va,
245 (paddr_t *)&dev->sc_bump_pa);
246
247 /*
248 * Setup pages to noncachable, that way we don't have to flush the cache
249 * every time we need "bumped" transfer.
250 */
251 pte = vtopte((vaddr_t) dev->sc_bump_va);
252 *pte &= ~L2_C;
253 PTE_SYNC(pte);
254 cpu_tlb_flushD();
255 cpu_dcache_wbinv_range((vm_offset_t)dev->sc_bump_va, PAGE_SIZE);
256
257 printf(" dmabuf V0x%08x P0x%08x", (u_int)dev->sc_bump_va, (u_int)dev->sc_bump_pa);
258 }
259
260
261 /*
262 * used by specific esc controller
263 */
264 void
265 esc_scsi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
266 void *arg)
267 {
268 struct scsipi_xfer *xs;
269 struct esc_softc *dev = (void *)chan->chan_adapter->adapt_dev;
270 struct scsipi_periph *periph;
271 struct esc_pending *pendp;
272 int flags, s, target;
273
274 switch (req) {
275 case ADAPTER_REQ_RUN_XFER:
276 xs = arg;
277 periph = xs->xs_periph;
278 flags = xs->xs_control;
279 target = periph->periph_target;
280
281 if (flags & XS_CTL_DATA_UIO)
282 panic("esc: scsi data uio requested");
283
284 if ((flags & XS_CTL_POLL) && (dev->sc_flags & ESC_ACTIVE))
285 panic("esc_scsicmd: busy");
286
287 /* Get hold of a esc_pending block. */
288 s = splbio();
289 pendp = dev->sc_xs_free.tqh_first;
290 if (pendp == NULL) {
291 splx(s);
292 xs->error = XS_RESOURCE_SHORTAGE;
293 scsipi_done(xs);
294 return;
295 }
296 TAILQ_REMOVE(&dev->sc_xs_free, pendp, link);
297 pendp->xs = xs;
298 splx(s);
299
300
301 /* If the chip if busy OR the unit is busy, we have to wait for out turn. */
302 if ((dev->sc_flags & ESC_ACTIVE) ||
303 (dev->sc_nexus[target].flags & ESC_NF_UNIT_BUSY)) {
304 s = splbio();
305 TAILQ_INSERT_TAIL(&dev->sc_xs_pending, pendp, link);
306 splx(s);
307 } else
308 esc_donextcmd(dev, pendp);
309
310 return;
311 case ADAPTER_REQ_GROW_RESOURCES:
312 case ADAPTER_REQ_SET_XFER_MODE:
313 /* XXX Not supported. */
314 return;
315 }
316
317 }
318
319 /*
320 * Actually select the unit, whereby the whole scsi-process is started.
321 */
322 void
323 esc_donextcmd(struct esc_softc *dev, struct esc_pending *pendp)
324 {
325 int s;
326
327 /*
328 * Special case for scsi unit reset. I think this is waterproof. We first
329 * select the unit during splbio. We then cycle through the generated
330 * interrupts until the interrupt routine signals that the unit has
331 * acknowledged the reset. After that we have to wait a reset to select
332 * delay before anything else can happend.
333 */
334 if (pendp->xs->xs_control & XS_CTL_RESET) {
335 struct nexus *nexus;
336
337 s = splbio();
338 while(!escselect(dev, pendp, 0, 0, 0, 0, ESC_SELECT_K)) {
339 splx(s);
340 delay(10);
341 s = splbio();
342 }
343
344 nexus = dev->sc_cur_nexus;
345 while(nexus->flags & ESC_NF_UNIT_BUSY) {
346 esciwait(dev);
347 escintr(dev);
348 }
349
350 nexus->flags |= ESC_NF_UNIT_BUSY;
351 splx(s);
352
353 escreset(dev, 0);
354
355 s = splbio();
356 nexus->flags &= ~ESC_NF_UNIT_BUSY;
357 splx(s);
358 }
359
360 /*
361 * If we are polling, go to splbio and perform the command, else we poke
362 * the scsi-bus via escgo to get the interrupt machine going.
363 */
364 if (pendp->xs->xs_control & XS_CTL_POLL) {
365 s = splbio();
366 escicmd(dev, pendp);
367 TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link);
368 splx(s);
369 } else {
370 escgo(dev, pendp);
371 return;
372 }
373 }
374
375 void
376 esc_scsidone(struct esc_softc *dev, struct scsipi_xfer *xs, int stat)
377 {
378 struct esc_pending *pendp;
379 int s;
380
381 xs->status = stat;
382
383 if (stat == 0)
384 xs->resid = 0;
385 else {
386 switch(stat) {
387 case SCSI_CHECK:
388 case SCSI_BUSY:
389 xs->error = XS_BUSY;
390 break;
391 case -1:
392 xs->error = XS_DRIVER_STUFFUP;
393 QPRINTF(("esc_scsicmd() bad %x\n", stat));
394 break;
395 default:
396 xs->error = XS_TIMEOUT;
397 break;
398 }
399 }
400
401 /* Steal the next command from the queue so that one unit can't hog the bus. */
402 s = splbio();
403 pendp = dev->sc_xs_pending.tqh_first;
404 while(pendp) {
405 if (!(dev->sc_nexus[pendp->xs->xs_periph->periph_target].flags &
406 ESC_NF_UNIT_BUSY))
407 break;
408 pendp = pendp->link.tqe_next;
409 }
410
411 if (pendp != NULL) {
412 TAILQ_REMOVE(&dev->sc_xs_pending, pendp, link);
413 }
414
415 splx(s);
416 scsipi_done(xs);
417
418 if (pendp)
419 esc_donextcmd(dev, pendp);
420 }
421
422 /*
423 * There are two kinds of reset:
424 * 1) CHIP-bus reset. This also implies a SCSI-bus reset.
425 * 2) SCSI-bus reset.
426 * After the appropriate resets have been performed we wait a reset to select
427 * delay time.
428 */
429 void
430 escreset(struct esc_softc *dev, int how)
431 {
432 esc_regmap_p rp;
433 int i, s;
434
435 rp = dev->sc_esc;
436
437 if (how & 1) {
438 for(i=0; i<8; i++)
439 esc_init_nexus(dev, &dev->sc_nexus[i]);
440
441 *rp->esc_command = ESC_CMD_RESET_CHIP;
442 delay(1);
443 *rp->esc_command = ESC_CMD_NOP;
444
445 *rp->esc_config1 = dev->sc_config1;
446 *rp->esc_config2 = dev->sc_config2;
447 *rp->esc_config3 = dev->sc_config3;
448 *rp->esc_config4 = dev->sc_config4;
449 *rp->esc_timeout = dev->sc_timeout_val;
450 *rp->esc_clkconv = dev->sc_clock_conv_fact &
451 ESC_CLOCK_CONVERSION_MASK;
452 }
453
454 if (how & 2) {
455 for(i=0; i<8; i++)
456 esc_init_nexus(dev, &dev->sc_nexus[i]);
457
458 s = splbio();
459
460 *rp->esc_command = ESC_CMD_RESET_SCSI_BUS;
461 delay(100);
462
463 /* Skip interrupt generated by RESET_SCSI_BUS */
464 while(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING) {
465 dev->sc_status = *rp->esc_status;
466 dev->sc_interrupt = *rp->esc_interrupt;
467
468 delay(100);
469 }
470
471 dev->sc_status = *rp->esc_status;
472 dev->sc_interrupt = *rp->esc_interrupt;
473
474 splx(s);
475 }
476
477 if (dev->sc_config_flags & ESC_SLOW_START)
478 delay(4*250000); /* RESET to SELECT DELAY*4 for slow devices */
479 else
480 delay(250000); /* RESET to SELECT DELAY */
481 }
482
483 /*
484 * Save active data pointers to the nexus block currently active.
485 */
486 void
487 esc_save_pointers(struct esc_softc *dev)
488 {
489 struct nexus *nx;
490
491 nx = dev->sc_cur_nexus;
492 if (nx) {
493 nx->cur_link = dev->sc_cur_link;
494 nx->max_link = dev->sc_max_link;
495 nx->buf = dev->sc_buf;
496 nx->len = dev->sc_len;
497 nx->dma_len = dev->sc_dma_len;
498 nx->dma_buf = dev->sc_dma_buf;
499 nx->dma_blk_flg = dev->sc_dma_blk_flg;
500 nx->dma_blk_len = dev->sc_dma_blk_len;
501 nx->dma_blk_ptr = dev->sc_dma_blk_ptr;
502 }
503 }
504
505 /*
506 * Restore data pointers from the currently active nexus block.
507 */
508 void
509 esc_restore_pointers(struct esc_softc *dev)
510 {
511 struct nexus *nx;
512
513 nx = dev->sc_cur_nexus;
514 if (nx) {
515 dev->sc_cur_link = nx->cur_link;
516 dev->sc_max_link = nx->max_link;
517 dev->sc_buf = nx->buf;
518 dev->sc_len = nx->len;
519 dev->sc_dma_len = nx->dma_len;
520 dev->sc_dma_buf = nx->dma_buf;
521 dev->sc_dma_blk_flg = nx->dma_blk_flg;
522 dev->sc_dma_blk_len = nx->dma_blk_len;
523 dev->sc_dma_blk_ptr = nx->dma_blk_ptr;
524 dev->sc_chain = nx->dma;
525 dev->sc_unit = (nx->lun_unit & 0x0F);
526 dev->sc_lun = (nx->lun_unit & 0xF0) >> 4;
527 }
528 }
529
530 /*
531 * esciwait is used during interrupt and polled IO to wait for an event from
532 * the FAS chip. This function MUST NOT BE CALLED without interrupt disabled.
533 */
534 void
535 esciwait(struct esc_softc *dev)
536 {
537 esc_regmap_p rp;
538
539 /*
540 * If ESC_DONT_WAIT is set, we have already grabbed the interrupt info
541 * elsewhere. So we don't have to wait for it.
542 */
543 if (dev->sc_flags & ESC_DONT_WAIT) {
544 dev->sc_flags &= ~ESC_DONT_WAIT;
545 return;
546 }
547
548 rp = dev->sc_esc;
549
550 /* Wait for FAS chip to signal an interrupt. */
551 while(!(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING));
552 /* delay(1);*/
553
554 /* Grab interrupt info from chip. */
555 dev->sc_status = *rp->esc_status;
556 dev->sc_interrupt = *rp->esc_interrupt;
557 if (dev->sc_interrupt & ESC_INT_RESELECTED) {
558 dev->sc_resel[0] = *rp->esc_fifo;
559 dev->sc_resel[1] = *rp->esc_fifo;
560 }
561 }
562
563 #if 0
564 /*
565 * Transfer info to/from device. esc_ixfer uses polled IO+esciwait so the
566 * rules that apply to esciwait also applies here.
567 */
568 void
569 esc_ixfer(struct esc_softc *dev)
570 {
571 esc_regmap_p rp;
572 u_char *buf;
573 int len, mode, phase;
574
575 rp = dev->sc_esc;
576 buf = dev->sc_buf;
577 len = dev->sc_len;
578
579 /*
580 * Decode the scsi phase to determine whether we are reading or writing.
581 * mode == 1 => READ, mode == 0 => WRITE
582 */
583 phase = dev->sc_status & ESC_STAT_PHASE_MASK;
584 mode = (phase == ESC_PHASE_DATA_IN);
585
586 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase))
587 if (mode) {
588 *rp->esc_command = ESC_CMD_TRANSFER_INFO;
589
590 esciwait(dev);
591
592 *buf++ = *rp->esc_fifo;
593 len--;
594 } else {
595 len--;
596 *rp->esc_fifo = *buf++;
597 *rp->esc_command = ESC_CMD_TRANSFER_INFO;
598
599 esciwait(dev);
600 }
601
602 /* Update buffer pointers to reflect the sent/received data. */
603 dev->sc_buf = buf;
604 dev->sc_len = len;
605
606 /*
607 * Since the last esciwait will be a phase-change, we can't wait for it
608 * again later, so we have to signal that.
609 */
610
611 dev->sc_flags |= ESC_DONT_WAIT;
612 }
613 #else
614 /*
615 * Transfer info to/from device. esc_ixfer uses polled IO+esciwait so the
616 * rules that apply to esciwait also applies here.
617 */
618 void
619 esc_ixfer(struct esc_softc *dev)
620 {
621 esc_regmap_p rp;
622 vu_char *esc_status;
623 vu_char *esc_command;
624 vu_char *esc_interrupt;
625 vu_char *esc_fifo;
626 u_char *buf;
627 int len, mode, phase;
628
629 rp = dev->sc_esc;
630 buf = dev->sc_buf;
631 len = dev->sc_len;
632
633 /* Use discrete variables for better optimisation */
634
635 esc_status = rp->esc_status;
636 esc_command = rp->esc_command;
637 esc_interrupt = rp->esc_interrupt;
638 esc_fifo = rp->esc_fifo;
639
640 /*
641 * Decode the scsi phase to determine whether we are reading or writing.
642 * mode == 1 => READ, mode == 0 => WRITE
643 */
644 phase = dev->sc_status & ESC_STAT_PHASE_MASK;
645 mode = (phase == ESC_PHASE_DATA_IN);
646
647 if (mode) {
648 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase)) {
649 *esc_command = ESC_CMD_TRANSFER_INFO;
650
651 /* Wait for FAS chip to signal an interrupt. */
652 while(!(*esc_status & ESC_STAT_INTERRUPT_PENDING));
653 /* delay(1);*/
654
655 /* Grab interrupt info from chip. */
656 dev->sc_status = *esc_status;
657 dev->sc_interrupt = *esc_interrupt;
658
659 *buf++ = *esc_fifo;
660 len--;
661 }
662 } else {
663 while(len && ((dev->sc_status & ESC_STAT_PHASE_MASK) == phase)) {
664 len--;
665 *esc_fifo = *buf++;
666 *esc_command = ESC_CMD_TRANSFER_INFO;
667
668 /* Wait for FAS chip to signal an interrupt. */
669 while(!(*esc_status & ESC_STAT_INTERRUPT_PENDING));
670 /* delay(1);*/
671
672 /* Grab interrupt info from chip. */
673 dev->sc_status = *esc_status;
674 dev->sc_interrupt = *esc_interrupt;
675 }
676 }
677
678 /* Update buffer pointers to reflect the sent/received data. */
679 dev->sc_buf = buf;
680 dev->sc_len = len;
681
682 /*
683 * Since the last esciwait will be a phase-change, we can't wait for it
684 * again later, so we have to signal that.
685 */
686
687 dev->sc_flags |= ESC_DONT_WAIT;
688 }
689 #endif
690
691 /*
692 * Build a Synchronous Data Transfer Request message
693 */
694 void
695 esc_build_sdtrm(struct esc_softc *dev, int period, int offset)
696 {
697 dev->sc_msg_out[0] = 0x01;
698 dev->sc_msg_out[1] = 0x03;
699 dev->sc_msg_out[2] = 0x01;
700 dev->sc_msg_out[3] = period/4;
701 dev->sc_msg_out[4] = offset;
702 dev->sc_msg_out_len= 5;
703 }
704
705 /*
706 * Arbitate the scsi bus and select the unit
707 */
708 int
709 esc_select_unit(struct esc_softc *dev, short target)
710 {
711 esc_regmap_p rp;
712 struct nexus *nexus;
713 int s, retcode, i;
714 u_char cmd;
715
716 s = splbio(); /* Do this at splbio so that we won't be disturbed. */
717
718 retcode = 0;
719
720 nexus = &dev->sc_nexus[target];
721
722 /*
723 * Check if the chip is busy. If not the we mark it as so and hope that nobody
724 * reselects us until we have grabbed the bus.
725 */
726 if (!(dev->sc_flags & ESC_ACTIVE) && !dev->sc_sel_nexus) {
727 dev->sc_flags |= ESC_ACTIVE;
728
729 rp = dev->sc_esc;
730
731 *rp->esc_syncper = nexus->syncper;
732 *rp->esc_syncoff = nexus->syncoff;
733 *rp->esc_config3 = nexus->config3;
734
735 *rp->esc_config1 = dev->sc_config1;
736 *rp->esc_timeout = dev->sc_timeout_val;
737 *rp->esc_dest_id = target;
738
739 /* If nobody has stolen the bus, we can send a select command to the chip. */
740 if (!(*rp->esc_status & ESC_STAT_INTERRUPT_PENDING)) {
741 *rp->esc_fifo = nexus->ID;
742 if ((nexus->flags & (ESC_NF_DO_SDTR | ESC_NF_RESET))
743 || (dev->sc_msg_out_len != 0))
744 cmd = ESC_CMD_SEL_ATN_STOP;
745 else {
746 for(i=0; i<nexus->clen; i++)
747 *rp->esc_fifo = nexus->cbuf[i];
748
749 cmd = ESC_CMD_SEL_ATN;
750 }
751
752 dev->sc_sel_nexus = nexus;
753
754 *rp->esc_command = cmd;
755 retcode = 1;
756 nexus->flags &= ~ESC_NF_RETRY_SELECT;
757 } else
758 nexus->flags |= ESC_NF_RETRY_SELECT;
759 } else
760 nexus->flags |= ESC_NF_RETRY_SELECT;
761
762 splx(s);
763 return(retcode);
764 }
765
766 /*
767 * Grab the nexus if available else return 0.
768 */
769 struct nexus *
770 esc_arbitate_target(struct esc_softc *dev, int target)
771 {
772 struct nexus *nexus;
773 int s;
774
775 /*
776 * This is realy simple. Raise interrupt level to splbio. Grab the nexus and
777 * leave.
778 */
779 nexus = &dev->sc_nexus[target];
780
781 s = splbio();
782
783 if (nexus->flags & ESC_NF_UNIT_BUSY)
784 nexus = 0;
785 else
786 nexus->flags |= ESC_NF_UNIT_BUSY;
787
788 splx(s);
789 return(nexus);
790 }
791
792 /*
793 * Setup a nexus for use. Initializes command, buffer pointers and DMA chain.
794 */
795 void
796 esc_setup_nexus(struct esc_softc *dev, struct nexus *nexus, struct esc_pending *pendp, unsigned char *cbuf, int clen, unsigned char *buf, int len, int mode)
797 {
798 int sync, target, lun;
799
800 target = pendp->xs->xs_periph->periph_target;
801 lun = pendp->xs->xs_periph->periph_lun;
802
803 /*
804 * Adopt mode to reflect the config flags.
805 * If we can't use DMA we can't use synch transfer. Also check the
806 * esc_inhibit_xxx[target] flags.
807 */
808 if ((dev->sc_config_flags & (ESC_NO_SYNCH | ESC_NO_DMA)) ||
809 esc_inhibit_sync[(int)target])
810 mode &= ~ESC_SELECT_S;
811
812 if ((dev->sc_config_flags & ESC_NO_RESELECT) ||
813 esc_inhibit_disc[(int)target])
814 mode &= ~ESC_SELECT_R;
815
816 nexus->xs = pendp->xs;
817
818 /* Setup the nexus struct. */
819 nexus->ID = ((mode & ESC_SELECT_R) ? 0xC0 : 0x80) | lun;
820 nexus->clen = clen;
821 memcpy(nexus->cbuf, cbuf, nexus->clen);
822 nexus->cbuf[1] |= lun << 5; /* Fix the lun bits */
823 nexus->cur_link = 0;
824 nexus->dma_len = 0;
825 nexus->dma_buf = 0;
826 nexus->dma_blk_len = 0;
827 nexus->dma_blk_ptr = 0;
828 nexus->len = len;
829 nexus->buf = buf;
830 nexus->lun_unit = (lun << 4) | target;
831 nexus->state = ESC_NS_SELECTED;
832
833 /* We must keep these flags. All else must be zero. */
834 nexus->flags &= ESC_NF_UNIT_BUSY
835 | ESC_NF_SYNC_TESTED | ESC_NF_SELECT_ME;
836
837 if (mode & ESC_SELECT_I)
838 nexus->flags |= ESC_NF_IMMEDIATE;
839 if (mode & ESC_SELECT_K)
840 nexus->flags |= ESC_NF_RESET;
841
842 sync = ((mode & ESC_SELECT_S) ? 1 : 0);
843
844 /* We can't use sync during polled IO. */
845 if (sync && (mode & ESC_SELECT_I))
846 sync = 0;
847
848 if (!sync &&
849 ((nexus->flags & ESC_NF_SYNC_TESTED) && (nexus->offset != 0))) {
850 /*
851 * If the scsi unit is set to synch transfer and we don't want
852 * that, we have to renegotiate.
853 */
854
855 nexus->flags |= ESC_NF_DO_SDTR;
856 nexus->period = 200;
857 nexus->offset = 0;
858 } else if (sync && !(nexus->flags & ESC_NF_SYNC_TESTED)) {
859 /*
860 * If the scsi unit is not set to synch transfer and we want
861 * that, we have to negotiate. This should realy base the
862 * period on the clock frequence rather than just check if
863 * >25 MHz
864 */
865
866 nexus->flags |= ESC_NF_DO_SDTR;
867 nexus->period = ((dev->sc_clock_freq>25) ? 100 : 200);
868 nexus->offset = 8;
869
870 /* If the user has a long cable, we want to limit the period */
871 if ((nexus->period == 100) &&
872 (dev->sc_config_flags & ESC_SLOW_CABLE))
873 nexus->period = 200;
874 }
875
876 /*
877 * Fake a DMA-block for polled IO. This way we can use the same code to handle
878 * reselection. Much nicer this way.
879 */
880 if ((mode & ESC_SELECT_I) || (dev->sc_config_flags & ESC_NO_DMA)) {
881 nexus->dma[0].ptr = buf;
882 nexus->dma[0].len = len;
883 nexus->dma[0].flg = ESC_CHAIN_PRG;
884 nexus->max_link = 1;
885 } else {
886 nexus->max_link = dev->sc_build_dma_chain(dev, nexus->dma,
887 buf, len);
888 }
889
890 /* Flush the caches. */
891
892 if (len && !(mode & ESC_SELECT_I))
893 cpu_dcache_wbinv_range((vm_offset_t)buf, len);
894 }
895
896 int
897 escselect(struct esc_softc *dev, struct esc_pending *pendp, unsigned char *cbuf, int clen, unsigned char *buf, int len, int mode)
898 {
899 struct nexus *nexus;
900
901 /* Get the nexus struct. */
902 nexus = esc_arbitate_target(dev, pendp->xs->xs_periph->periph_target);
903 if (nexus == NULL)
904 return(0);
905
906 /* Setup the nexus struct. */
907 esc_setup_nexus(dev, nexus, pendp, cbuf, clen, buf, len, mode);
908
909 /* Post it to the interrupt machine. */
910 esc_select_unit(dev, pendp->xs->xs_periph->periph_target);
911
912 return(1);
913 }
914
915 int
916 escgo(struct esc_softc *dev, struct esc_pending *pendp)
917 {
918 int s;
919 char *buf;
920
921 buf = pendp->xs->data;
922
923 if (escselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen,
924 buf, pendp->xs->datalen, ESC_SELECT_RS)) {
925 /*
926 * We got the command going so the esc_pending struct is now
927 * free to reuse.
928 */
929
930 s = splbio();
931 TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link);
932 splx(s);
933 } else {
934 /*
935 * We couldn't make the command fly so we have to wait. The
936 * struct MUST be inserted at the head to keep the order of
937 * the commands.
938 */
939
940 s = splbio();
941 TAILQ_INSERT_HEAD(&dev->sc_xs_pending, pendp, link);
942 splx(s);
943 }
944
945 return(0);
946 }
947
948 /*
949 * Part one of the interrupt machine. Error checks and reselection test.
950 * We don't know if we have an active nexus here!
951 */
952 int
953 esc_pretests(struct esc_softc *dev, esc_regmap_p rp)
954 {
955 struct nexus *nexus;
956 int i, s;
957
958 if (dev->sc_interrupt & ESC_INT_SCSI_RESET_DETECTED) {
959 /*
960 * Cleanup and notify user. Lets hope that this is all we
961 * have to do
962 */
963
964 for(i=0; i<8; i++) {
965 if (dev->sc_nexus[i].xs)
966 esc_scsidone(dev, dev->sc_nexus[i].xs, -2);
967
968 esc_init_nexus(dev, &dev->sc_nexus[i]);
969 }
970 printf("escintr: SCSI-RESET detected!");
971 return(-1);
972 }
973
974 if (dev->sc_interrupt & ESC_INT_ILLEGAL_COMMAND) {
975 /* Something went terrible wrong! Dump some data and panic! */
976
977 printf("FIFO:");
978 while(*rp->esc_fifo_flags & ESC_FIFO_COUNT_MASK)
979 printf(" %x", *rp->esc_fifo);
980 printf("\n");
981
982 printf("CMD: %x\n", *rp->esc_command);
983 panic("escintr: ILLEGAL COMMAND!");
984 }
985
986 if (dev->sc_interrupt & ESC_INT_RESELECTED) {
987 /* We were reselected. Set the chip as busy */
988
989 s = splbio();
990 dev->sc_flags |= ESC_ACTIVE;
991 if (dev->sc_sel_nexus) {
992 dev->sc_sel_nexus->flags |= ESC_NF_SELECT_ME;
993 dev->sc_sel_nexus = 0;
994 }
995 splx(s);
996
997 if (dev->sc_units_disconnected) {
998 /* Find out who reselected us. */
999
1000 dev->sc_resel[0] &= ~(1<<dev->sc_host_id);
1001
1002 for(i=0; i<8; i++)
1003 if (dev->sc_resel[0] & (1<<i))
1004 break;
1005
1006 if (i == 8)
1007 panic("Illegal reselection!");
1008
1009 if (dev->sc_nexus[i].state == ESC_NS_DISCONNECTED) {
1010 /*
1011 * This unit had disconnected, so we reconnect
1012 * it.
1013 */
1014
1015 dev->sc_cur_nexus = &dev->sc_nexus[i];
1016 nexus = dev->sc_cur_nexus;
1017
1018 *rp->esc_syncper = nexus->syncper;
1019 *rp->esc_syncoff = nexus->syncoff;
1020 *rp->esc_config3 = nexus->config3;
1021
1022 *rp->esc_dest_id = i & 7;
1023
1024 dev->sc_units_disconnected--;
1025 dev->sc_msg_in_len= 0;
1026
1027 /* Restore active pointers. */
1028 esc_restore_pointers(dev);
1029
1030 nexus->state = ESC_NS_RESELECTED;
1031
1032 *rp->esc_command = ESC_CMD_MESSAGE_ACCEPTED;
1033
1034 return(1);
1035 }
1036 }
1037
1038 /* Somehow we got an illegal reselection. Dump and panic. */
1039 printf("escintr: resel[0] %x resel[1] %x disconnected %d\n",
1040 dev->sc_resel[0], dev->sc_resel[1],
1041 dev->sc_units_disconnected);
1042 panic("escintr: Unexpected reselection!");
1043 }
1044
1045 return(0);
1046 }
1047
1048 /*
1049 * Part two of the interrupt machine. Handle disconnection and post command
1050 * processing. We know that we have an active nexus here.
1051 */
1052 int
1053 esc_midaction(struct esc_softc *dev, esc_regmap_p rp, struct nexus *nexus)
1054 {
1055 int i, left, len, s;
1056 u_char status, msg;
1057
1058 if (dev->sc_interrupt & ESC_INT_DISCONNECT) {
1059 s = splbio();
1060 dev->sc_cur_nexus = 0;
1061
1062 /* Mark chip as busy and clean up the chip FIFO. */
1063 dev->sc_flags &= ~ESC_ACTIVE;
1064 *rp->esc_command = ESC_CMD_FLUSH_FIFO;
1065
1066 /* Let the nexus state reflect what we have to do. */
1067 switch(nexus->state) {
1068 case ESC_NS_SELECTED:
1069 dev->sc_sel_nexus = 0;
1070 nexus->flags &= ~ESC_NF_SELECT_ME;
1071
1072 /*
1073 * We were trying to select the unit. Probably no unit
1074 * at this ID.
1075 */
1076 nexus->xs->resid = dev->sc_len;
1077
1078 nexus->status = -2;
1079 nexus->flags &= ~ESC_NF_UNIT_BUSY;
1080 nexus->state = ESC_NS_FINISHED;
1081 break;
1082
1083 case ESC_NS_DONE:
1084 /* All done. */
1085 nexus->xs->resid = dev->sc_len;
1086
1087 nexus->flags &= ~ESC_NF_UNIT_BUSY;
1088 nexus->state = ESC_NS_FINISHED;
1089 dev->sc_led(dev, 0);
1090 break;
1091
1092 case ESC_NS_DISCONNECTING:
1093 /*
1094 * We have received a DISCONNECT message, so we are
1095 * doing a normal disconnection.
1096 */
1097 nexus->state = ESC_NS_DISCONNECTED;
1098
1099 dev->sc_units_disconnected++;
1100 break;
1101
1102 case ESC_NS_RESET:
1103 /*
1104 * We were reseting this SCSI-unit. Clean up the
1105 * nexus struct.
1106 */
1107 dev->sc_led(dev, 0);
1108 esc_init_nexus(dev, nexus);
1109 break;
1110
1111 default:
1112 /*
1113 * Unexpected disconnection! Cleanup and exit. This
1114 * shouldn't cause any problems.
1115 */
1116 printf("escintr: Unexpected disconnection\n");
1117 printf("escintr: u %x s %d p %d f %x c %x\n",
1118 nexus->lun_unit, nexus->state,
1119 dev->sc_status & ESC_STAT_PHASE_MASK,
1120 nexus->flags, nexus->cbuf[0]);
1121
1122 nexus->xs->resid = dev->sc_len;
1123
1124 nexus->flags &= ~ESC_NF_UNIT_BUSY;
1125 nexus->state = ESC_NS_FINISHED;
1126 nexus->status = -3;
1127
1128 dev->sc_led(dev, 0);
1129 break;
1130 }
1131
1132 /*
1133 * If we have disconnected units, we MUST enable reselection
1134 * within 250ms.
1135 */
1136 if (dev->sc_units_disconnected &&
1137 !(dev->sc_flags & ESC_ACTIVE))
1138 *rp->esc_command = ESC_CMD_ENABLE_RESEL;
1139
1140 splx(s);
1141
1142 /* Select the first pre-initialized nexus we find. */
1143 for(i=0; i<8; i++)
1144 if (dev->sc_nexus[i].flags & (ESC_NF_SELECT_ME | ESC_NF_RETRY_SELECT))
1145 if (esc_select_unit(dev, i) == 2)
1146 break;
1147
1148 /* We are done with this nexus! */
1149 if (nexus->state == ESC_NS_FINISHED)
1150 esc_scsidone(dev, nexus->xs, nexus->status);
1151
1152 return(1);
1153 }
1154
1155 switch(nexus->state) {
1156 case ESC_NS_SELECTED:
1157 dev->sc_cur_nexus = nexus;
1158 dev->sc_sel_nexus = 0;
1159
1160 nexus->flags &= ~ESC_NF_SELECT_ME;
1161
1162 /*
1163 * We have selected a unit. Setup chip, restore pointers and
1164 * light the led.
1165 */
1166 *rp->esc_syncper = nexus->syncper;
1167 *rp->esc_syncoff = nexus->syncoff;
1168 *rp->esc_config3 = nexus->config3;
1169
1170 esc_restore_pointers(dev);
1171
1172 nexus->status = 0xFF;
1173 dev->sc_msg_in[0] = 0xFF;
1174 dev->sc_msg_in_len= 0;
1175
1176 dev->sc_led(dev, 1);
1177
1178 break;
1179
1180 case ESC_NS_DATA_IN:
1181 case ESC_NS_DATA_OUT:
1182 /* We have transfered data. */
1183 if (dev->sc_dma_len)
1184 if (dev->sc_cur_link < dev->sc_max_link) {
1185 /*
1186 * Clean up DMA and at the same time get how
1187 * many bytes that were NOT transfered.
1188 */
1189 left = dev->sc_setup_dma(dev, 0, 0, ESC_DMA_CLEAR);
1190 len = dev->sc_dma_len;
1191
1192 if (nexus->state == ESC_NS_DATA_IN) {
1193 /*
1194 * If we were bumping we may have had an odd length
1195 * which means that there may be bytes left in the
1196 * fifo. We also need to move the data from the
1197 * bump buffer to the actual memory.
1198 */
1199 if (dev->sc_dma_buf == dev->sc_bump_pa)
1200 {
1201 while((*rp->esc_fifo_flags&ESC_FIFO_COUNT_MASK)
1202 && left)
1203 dev->sc_bump_va[len-(left--)] = *rp->esc_fifo;
1204
1205 memcpy(dev->sc_buf, dev->sc_bump_va, len-left);
1206 }
1207 } else {
1208 /* Count any unsent bytes and flush them. */
1209 left+= *rp->esc_fifo_flags & ESC_FIFO_COUNT_MASK;
1210 *rp->esc_command = ESC_CMD_FLUSH_FIFO;
1211 }
1212
1213 /*
1214 * Update pointers/length to reflect the transfered
1215 * data.
1216 */
1217 dev->sc_len -= len-left;
1218 dev->sc_buf += len-left;
1219
1220 dev->sc_dma_buf = (char *)dev->sc_dma_buf + len-left;
1221 dev->sc_dma_len = left;
1222
1223 dev->sc_dma_blk_ptr = (char *)dev->sc_dma_blk_ptr +
1224 len-left;
1225 dev->sc_dma_blk_len -= len-left;
1226
1227 /*
1228 * If it was the end of a DMA block, we select the
1229 * next to begin with.
1230 */
1231 if (!dev->sc_dma_blk_len)
1232 dev->sc_cur_link++;
1233 }
1234 break;
1235
1236 case ESC_NS_STATUS:
1237 /*
1238 * If we were not sensing, grab the status byte. If we were
1239 * sensing and we got a bad status, let the user know.
1240 */
1241
1242 status = *rp->esc_fifo;
1243 msg = *rp->esc_fifo;
1244
1245 nexus->status = status;
1246 if (status != 0)
1247 nexus->status = -1;
1248
1249 /*
1250 * Preload the command complete message. Handeled in
1251 * esc_postaction.
1252 */
1253 dev->sc_msg_in[0] = msg;
1254 dev->sc_msg_in_len = 1;
1255 nexus->flags |= ESC_NF_HAS_MSG;
1256 break;
1257
1258 default:
1259 break;
1260 }
1261
1262 return(0);
1263 }
1264
1265 /*
1266 * Part three of the interrupt machine. Handle phase changes (and repeated
1267 * phase passes). We know that we have an active nexus here.
1268 */
1269 int
1270 esc_postaction(struct esc_softc *dev, esc_regmap_p rp, struct nexus *nexus)
1271 {
1272 int i, len;
1273 u_char cmd;
1274 short offset, period;
1275
1276 cmd = 0;
1277
1278 switch(dev->sc_status & ESC_STAT_PHASE_MASK) {
1279 case ESC_PHASE_DATA_OUT:
1280 case ESC_PHASE_DATA_IN:
1281 if ((dev->sc_status & ESC_STAT_PHASE_MASK) ==
1282 ESC_PHASE_DATA_OUT)
1283 nexus->state = ESC_NS_DATA_OUT;
1284 else
1285 nexus->state = ESC_NS_DATA_IN;
1286
1287 /* Make DMA ready to accept new data. Load active pointers
1288 * from the DMA block. */
1289 dev->sc_setup_dma(dev, 0, 0, ESC_DMA_CLEAR);
1290 if (dev->sc_cur_link < dev->sc_max_link) {
1291 if (!dev->sc_dma_blk_len) {
1292 dev->sc_dma_blk_ptr = dev->sc_chain[dev->sc_cur_link].ptr;
1293 dev->sc_dma_blk_len = dev->sc_chain[dev->sc_cur_link].len;
1294 dev->sc_dma_blk_flg = dev->sc_chain[dev->sc_cur_link].flg;
1295 }
1296
1297 /* We should use polled IO here. */
1298 if (dev->sc_dma_blk_flg == ESC_CHAIN_PRG) {
1299 esc_ixfer(dev/*, nexus->xs->xs_control & XS_CTL_POLL*/);
1300 dev->sc_cur_link++;
1301 dev->sc_dma_len = 0;
1302 break;
1303 }
1304 else if (dev->sc_dma_blk_flg == ESC_CHAIN_BUMP)
1305 len = dev->sc_dma_blk_len;
1306 else
1307 len = dev->sc_need_bump(dev,
1308 (void *)dev->sc_dma_blk_ptr,
1309 dev->sc_dma_blk_len);
1310
1311 /*
1312 * If len != 0 we must bump the data, else we just DMA it
1313 * straight into memory.
1314 */
1315 if (len) {
1316 dev->sc_dma_buf = dev->sc_bump_pa;
1317 dev->sc_dma_len = len;
1318
1319 if (nexus->state == ESC_NS_DATA_OUT)
1320 memcpy(dev->sc_bump_va, dev->sc_buf, dev->sc_dma_len);
1321 } else {
1322 dev->sc_dma_buf = dev->sc_dma_blk_ptr;
1323 dev->sc_dma_len = dev->sc_dma_blk_len;
1324 }
1325
1326 /* Load DMA with address and length of transfer. */
1327 dev->sc_setup_dma(dev, (void *)dev->sc_dma_buf,
1328 dev->sc_dma_len,
1329 ((nexus->state == ESC_NS_DATA_OUT) ?
1330 ESC_DMA_WRITE : ESC_DMA_READ));
1331
1332 printf("Using DMA !!!!\n");
1333 cmd = ESC_CMD_TRANSFER_INFO | ESC_CMD_DMA;
1334 } else {
1335 /*
1336 * Hmmm, the unit wants more info than we have or has
1337 * more than we want. Let the chip handle that.
1338 */
1339
1340 *rp->esc_tc_low = 0;
1341 *rp->esc_tc_mid = 1;
1342 *rp->esc_tc_high = 0;
1343 cmd = ESC_CMD_TRANSFER_PAD;
1344 }
1345 break;
1346
1347 case ESC_PHASE_COMMAND:
1348 /* The scsi unit wants the command, send it. */
1349 nexus->state = ESC_NS_SVC;
1350
1351 *rp->esc_command = ESC_CMD_FLUSH_FIFO;
1352 for(i=0; i<5; i++);
1353
1354 for(i=0; i<nexus->clen; i++)
1355 *rp->esc_fifo = nexus->cbuf[i];
1356 cmd = ESC_CMD_TRANSFER_INFO;
1357 break;
1358
1359 case ESC_PHASE_STATUS:
1360 /*
1361 * We've got status phase. Request status and command
1362 * complete message.
1363 */
1364 nexus->state = ESC_NS_STATUS;
1365 cmd = ESC_CMD_COMMAND_COMPLETE;
1366 break;
1367
1368 case ESC_PHASE_MESSAGE_OUT:
1369 /*
1370 * Either the scsi unit wants us to send a message or we have
1371 * asked for it by seting the ATN bit.
1372 */
1373 nexus->state = ESC_NS_MSG_OUT;
1374
1375 *rp->esc_command = ESC_CMD_FLUSH_FIFO;
1376
1377 if (nexus->flags & ESC_NF_DO_SDTR) {
1378 /* Send a Synchronous Data Transfer Request. */
1379
1380 esc_build_sdtrm(dev, nexus->period, nexus->offset);
1381 nexus->flags |= ESC_NF_SDTR_SENT;
1382 nexus->flags &= ~ESC_NF_DO_SDTR;
1383 } else if (nexus->flags & ESC_NF_RESET) {
1384 /* Send a reset scsi unit message. */
1385
1386 dev->sc_msg_out[0] = 0x0C;
1387 dev->sc_msg_out_len = 1;
1388 nexus->state = ESC_NS_RESET;
1389 nexus->flags &= ~ESC_NF_RESET;
1390 } else if (dev->sc_msg_out_len == 0) {
1391 /* Don't know what to send so we send a NOP message. */
1392
1393 dev->sc_msg_out[0] = 0x08;
1394 dev->sc_msg_out_len = 1;
1395 }
1396
1397 cmd = ESC_CMD_TRANSFER_INFO;
1398
1399 for(i=0; i<dev->sc_msg_out_len; i++)
1400 *rp->esc_fifo = dev->sc_msg_out[i];
1401 dev->sc_msg_out_len = 0;
1402
1403 break;
1404
1405 case ESC_PHASE_MESSAGE_IN:
1406 /* Receive a message from the scsi unit. */
1407 nexus->state = ESC_NS_MSG_IN;
1408
1409 while(!(nexus->flags & ESC_NF_HAS_MSG)) {
1410 *rp->esc_command = ESC_CMD_TRANSFER_INFO;
1411 esciwait(dev);
1412
1413 dev->sc_msg_in[dev->sc_msg_in_len++] = *rp->esc_fifo;
1414
1415 /* Check if we got all the bytes in the message. */
1416 if (dev->sc_msg_in[0] >= 0x80) ;
1417 else if (dev->sc_msg_in[0] >= 0x30) ;
1418 else if (((dev->sc_msg_in[0] >= 0x20) &&
1419 (dev->sc_msg_in_len == 2)) ||
1420 ((dev->sc_msg_in[0] != 0x01) &&
1421 (dev->sc_msg_in_len == 1))) {
1422 nexus->flags |= ESC_NF_HAS_MSG;
1423 break;
1424 } else {
1425 if (dev->sc_msg_in_len >= 2)
1426 if ((dev->sc_msg_in[1]+2) == dev->sc_msg_in_len) {
1427 nexus->flags |= ESC_NF_HAS_MSG;
1428 break;
1429 }
1430 }
1431
1432 *rp->esc_command = ESC_CMD_MESSAGE_ACCEPTED;
1433 esciwait(dev);
1434
1435 if ((dev->sc_status & ESC_STAT_PHASE_MASK) !=
1436 ESC_PHASE_MESSAGE_IN)
1437 break;
1438 }
1439
1440 cmd = ESC_CMD_MESSAGE_ACCEPTED;
1441 if (nexus->flags & ESC_NF_HAS_MSG) {
1442 /* We have a message. Decode it. */
1443
1444 switch(dev->sc_msg_in[0]) {
1445 case 0x00: /* COMMAND COMPLETE */
1446 nexus->state = ESC_NS_DONE;
1447 case 0x04: /* DISCONNECT */
1448 nexus->state = ESC_NS_DISCONNECTING;
1449 break;
1450 case 0x02: /* SAVE DATA POINTER */
1451 esc_save_pointers(dev);
1452 break;
1453 case 0x03: /* RESTORE DATA POINTERS */
1454 esc_restore_pointers(dev);
1455 break;
1456 case 0x07: /* MESSAGE REJECT */
1457 /*
1458 * If we had sent a SDTR and we got a message
1459 * reject, the scsi docs say that we must go
1460 * to async transfer.
1461 */
1462 if (nexus->flags & ESC_NF_SDTR_SENT) {
1463 nexus->flags &= ~ESC_NF_SDTR_SENT;
1464
1465 nexus->config3 &= ~ESC_CFG3_FASTSCSI;
1466 nexus->syncper = 5;
1467 nexus->syncoff = 0;
1468
1469 *rp->esc_syncper = nexus->syncper;
1470 *rp->esc_syncoff = nexus->syncoff;
1471 *rp->esc_config3 = nexus->config3;
1472 } else
1473 /*
1474 * Something was rejected but we don't know
1475 * what! PANIC!
1476 */
1477 panic("escintr: Unknown message rejected!");
1478 break;
1479 case 0x08: /* MO OPERATION */
1480 break;
1481 case 0x01: /* EXTENDED MESSAGE */
1482 switch(dev->sc_msg_in[2]) {
1483 case 0x01:/* SYNC. DATA TRANSFER REQUEST */
1484 /* Decode the SDTR message. */
1485 period = 4*dev->sc_msg_in[3];
1486 offset = dev->sc_msg_in[4];
1487
1488 /*
1489 * Make sure that the specs are within
1490 * chip limits. Note that if we
1491 * initiated the negotiation the specs
1492 * WILL be withing chip limits. If it
1493 * was the scsi unit that initiated
1494 * the negotiation, the specs may be
1495 * to high.
1496 */
1497 if (offset > 16)
1498 offset = 16;
1499 if ((period < 200) &&
1500 (dev->sc_clock_freq <= 25))
1501 period = 200;
1502
1503 if (offset == 0)
1504 period = 5*dev->sc_clock_period;
1505
1506 nexus->syncper = period/
1507 dev->sc_clock_period;
1508 nexus->syncoff = offset;
1509
1510 if (period < 200)
1511 nexus->config3 |= ESC_CFG3_FASTSCSI;
1512 else
1513 nexus->config3 &=~ESC_CFG3_FASTSCSI;
1514
1515 nexus->flags |= ESC_NF_SYNC_TESTED;
1516
1517 *rp->esc_syncper = nexus->syncper;
1518 *rp->esc_syncoff = nexus->syncoff;
1519 *rp->esc_config3 = nexus->config3;
1520
1521 /*
1522 * Hmmm, it seems that the scsi unit
1523 * initiated sync negotiation, so lets
1524 * reply acording to scsi-2 standard.
1525 */
1526 if (!(nexus->flags& ESC_NF_SDTR_SENT))
1527 {
1528 if ((dev->sc_config_flags &
1529 ESC_NO_SYNCH) ||
1530 (dev->sc_config_flags &
1531 ESC_NO_DMA) ||
1532 esc_inhibit_sync[
1533 nexus->lun_unit & 7]) {
1534 period = 200;
1535 offset = 0;
1536 }
1537
1538 nexus->offset = offset;
1539 nexus->period = period;
1540 nexus->flags |= ESC_NF_DO_SDTR;
1541 *rp->esc_command = ESC_CMD_SET_ATN;
1542 }
1543
1544 nexus->flags &= ~ESC_NF_SDTR_SENT;
1545 break;
1546
1547 case 0x00: /* MODIFY DATA POINTERS */
1548 case 0x02: /* EXTENDED IDENTIFY (SCSI-1) */
1549 case 0x03: /* WIDE DATA TRANSFER REQUEST */
1550 default:
1551 /* Reject any unhandeled messages. */
1552
1553 dev->sc_msg_out[0] = 0x07;
1554 dev->sc_msg_out_len = 1;
1555 *rp->esc_command = ESC_CMD_SET_ATN;
1556 cmd = ESC_CMD_MESSAGE_ACCEPTED;
1557 break;
1558 }
1559 break;
1560
1561 default:
1562 /* Reject any unhandeled messages. */
1563
1564 dev->sc_msg_out[0] = 0x07;
1565 dev->sc_msg_out_len = 1;
1566 *rp->esc_command = ESC_CMD_SET_ATN;
1567 cmd = ESC_CMD_MESSAGE_ACCEPTED;
1568 break;
1569 }
1570 nexus->flags &= ~ESC_NF_HAS_MSG;
1571 dev->sc_msg_in_len = 0;
1572 }
1573 break;
1574 default:
1575 printf("ESCINTR: UNKNOWN PHASE! phase: %d\n",
1576 dev->sc_status & ESC_STAT_PHASE_MASK);
1577 dev->sc_led(dev, 0);
1578 esc_scsidone(dev, nexus->xs, -4);
1579
1580 return(-1);
1581 }
1582
1583 if (cmd)
1584 *rp->esc_command = cmd;
1585
1586 return(0);
1587 }
1588
1589 /*
1590 * Stub for interrupt machine.
1591 */
1592 void
1593 escintr(struct esc_softc *dev)
1594 {
1595 esc_regmap_p rp;
1596 struct nexus *nexus;
1597
1598 rp = dev->sc_esc;
1599
1600 if (!esc_pretests(dev, rp)) {
1601
1602 nexus = dev->sc_cur_nexus;
1603 if (nexus == NULL)
1604 nexus = dev->sc_sel_nexus;
1605
1606 if (nexus)
1607 if (!esc_midaction(dev, rp, nexus))
1608 esc_postaction(dev, rp, nexus);
1609 }
1610 }
1611
1612 /*
1613 * escicmd is used to perform IO when we can't use interrupts. escicmd
1614 * emulates the normal environment by waiting for the chip and calling
1615 * escintr.
1616 */
1617 void
1618 escicmd(struct esc_softc *dev, struct esc_pending *pendp)
1619 {
1620 esc_regmap_p rp;
1621 struct nexus *nexus;
1622
1623 nexus = &dev->sc_nexus[pendp->xs->xs_periph->periph_target];
1624 rp = dev->sc_esc;
1625
1626 if (!escselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen,
1627 (char *)pendp->xs->data, pendp->xs->datalen,
1628 ESC_SELECT_I))
1629 panic("escicmd: Couldn't select unit");
1630
1631 while(nexus->state != ESC_NS_FINISHED) {
1632 esciwait(dev);
1633 escintr(dev);
1634 }
1635
1636 nexus->flags &= ~ESC_NF_SYNC_TESTED;
1637 }
NetBSD on the FriendlyARM MINI2440