1 /* $NetBSD: atari5380.c,v 1.66 2023/01/06 10:28:28 tsutsui Exp $ */
2
3 /*
4 * Copyright (c) 1995 Leo Weppelman.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: atari5380.c,v 1.66 2023/01/06 10:28:28 tsutsui Exp $");
30
31 #include "opt_atariscsi.h"
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/device.h>
37 #include <sys/buf.h>
38 #include <dev/scsipi/scsi_all.h>
39 #include <dev/scsipi/scsipi_all.h>
40 #include <dev/scsipi/scsi_message.h>
41 #include <dev/scsipi/scsiconf.h>
42
43 #include <uvm/uvm_extern.h>
44
45 #include <m68k/asm_single.h>
46 #include <m68k/cpu.h>
47 #include <m68k/cacheops.h>
48
49 #include <atari/atari/stalloc.h>
50
51 /*
52 * Include the driver definitions
53 */
54 #include <atari/dev/ncr5380reg.h>
55
56 #include <machine/iomap.h>
57 #include <machine/mfp.h>
58 #include <machine/intr.h>
59
60 #if defined(FALCON_SCSI)
61 #include <machine/dma.h>
62 #endif
63
64 /*
65 * Set the various driver options
66 */
67 #define NREQ 18 /* Size of issue queue */
68 #define AUTO_SENSE 1 /* Automatically issue a request-sense */
69
70 #define DRNAME ncrscsi /* used in various prints */
71 #undef DBG_SEL /* Show the selection process */
72 #undef DBG_REQ /* Show enqueued/ready requests */
73 #undef DBG_ERR_RET /* Show requests with != 0 return code */
74 #undef DBG_NOWRITE /* Do not allow writes to the targets */
75 #undef DBG_PIO /* Show the polled-I/O process */
76 #undef DBG_INF /* Show information transfer process */
77 #define DBG_NOSTATIC /* No static functions, all in DDB trace*/
78 #define DBG_PID 15 /* Keep track of driver */
79 #define REAL_DMA /* Use DMA if sensible */
80 #if defined(FALCON_SCSI)
81 #define REAL_DMA_POLL 1 /* 1: Poll for end of DMA-transfer */
82 #else
83 #define REAL_DMA_POLL 0 /* 1: Poll for end of DMA-transfer */
84 #endif
85 #undef USE_PDMA /* Use special pdma-transfer function */
86 #define MIN_PHYS 65536 /*BARF!!!!*/
87
88 /*
89 * Include more driver definitions
90 */
91 #include <atari/dev/ncr5380var.h>
92
93 /*
94 * The atari specific driver options
95 */
96 #undef NO_TTRAM_DMA /* Do not use DMA to TT-ram. This */
97 /* fails on older atari's */
98 #define ENABLE_NCR5380(sc) cur_softc = sc;
99
100 static uint8_t *alloc_bounceb(u_long);
101 static void free_bounceb(uint8_t *);
102 static int machine_match(device_t, cfdata_t, void *, struct cfdriver *);
103
104 void scsi_ctrl(int);
105 void scsi_dma(int);
106
107 /*
108 * Functions that do nothing on the atari
109 */
110 #define pdma_ready() 0
111
112 #if defined(TT_SCSI)
113
114 void ncr5380_drq_intr(int);
115
116 /*
117 * Define all the things we need of the DMA-controller
118 */
119 #define SCSI_DMA ((struct scsi_dma *)AD_SCSI_DMA)
120 #define SCSI_5380 ((struct scsi_5380 *)AD_NCR5380)
121
122 struct scsi_dma {
123 volatile uint8_t s_dma_ptr[8]; /* use only the odd bytes */
124 volatile uint8_t s_dma_cnt[8]; /* use only the odd bytes */
125 volatile uint8_t s_dma_res[4]; /* data residue register */
126 volatile uint8_t s_dma_gap; /* not used */
127 volatile uint8_t s_dma_ctrl; /* control register */
128 volatile uint8_t s_dma_gap2; /* not used */
129 volatile uint8_t s_hdma_ctrl; /* Hades control register */
130 };
131
132 static inline void set_scsi_dma(volatile uint8_t *, u_long);
133 static inline u_long get_scsi_dma(volatile uint8_t *);
134
135 static inline void
set_scsi_dma(volatile uint8_t * addr,u_long val)136 set_scsi_dma(volatile uint8_t *addr, u_long val)
137 {
138 volatile uint8_t *address;
139
140 address = addr + 1;
141 __asm("movepl %0, %1@(0)": :"d" (val), "a" (address));
142 }
143
144 static inline u_long
get_scsi_dma(volatile uint8_t * addr)145 get_scsi_dma(volatile uint8_t *addr)
146 {
147 volatile uint8_t *address;
148 u_long nval;
149
150 address = addr + 1;
151 __asm("movepl %1@(0), %0": "=d" (nval) : "a" (address));
152
153 return nval;
154 }
155
156 /*
157 * Defines for TT-DMA control register
158 */
159 #define SD_BUSERR 0x80 /* 1 = transfer caused bus error*/
160 #define SD_ZERO 0x40 /* 1 = byte counter is zero */
161 #define SD_ENABLE 0x02 /* 1 = Enable DMA */
162 #define SD_OUT 0x01 /* Direction: memory to SCSI */
163 #define SD_IN 0x00 /* Direction: SCSI to memory */
164
165 /*
166 * Defines for Hades-DMA control register
167 */
168 #define SDH_BUSERR 0x02 /* 1 = Bus error */
169 #define SDH_EOP 0x01 /* 1 = Signal EOP on 5380 */
170 #define SDH_ZERO 0x40 /* 1 = Byte counter is zero */
171
172 /*
173 * Define the 5380 register set
174 */
175 struct scsi_5380 {
176 volatile uint8_t scsi_5380[16]; /* use only the odd bytes */
177 };
178 #endif /* TT_SCSI */
179
180 /**********************************************
181 * Variables present for both TT and Falcon. *
182 **********************************************/
183
184 /*
185 * Softc of currently active controller (a bit of fake; we only have one)
186 */
187 static struct ncr_softc *cur_softc;
188
189 #if defined(TT_SCSI) && !defined(FALCON_SCSI)
190 /*
191 * We can be more efficient for some functions when only TT_SCSI is selected
192 */
193 #define GET_5380_REG(rnum) SCSI_5380->scsi_5380[(rnum << 1) | 1]
194 #define SET_5380_REG(rnum,val) (SCSI_5380->scsi_5380[(rnum << 1) | 1] = val)
195
196 #define scsi_mach_init(sc) scsi_tt_init(sc)
197 #define scsi_ienable() scsi_tt_ienable()
198 #define scsi_idisable() scsi_tt_idisable()
199 #define scsi_clr_ipend() scsi_tt_clr_ipend()
200 #define scsi_ipending() (GET_5380_REG(NCR5380_DMSTAT) & SC_IRQ_SET)
201 #define scsi_dma_setup(r,p,m) scsi_tt_dmasetup(r, p, m)
202 #define wrong_dma_range(r,d) tt_wrong_dma_range(r, d)
203 #define poll_edma(reqp) tt_poll_edma(reqp)
204 #define get_dma_result(r, b) tt_get_dma_result(r, b)
205 #define can_access_5380() 1
206 #define emulated_dma() ((machineid & ATARI_HADES) ? 1 : 0)
207
208 #define fair_to_keep_dma() 1
209 #define claimed_dma() 1
210 #define reconsider_dma()
211
212 #endif /* defined(TT_SCSI) && !defined(FALCON_SCSI) */
213
214 #if defined(TT_SCSI)
215
216 /*
217 * Prototype functions defined below
218 */
219 #ifdef NO_TTRAM_DMA
220 static int tt_wrong_dma_range(SC_REQ *, struct dma_chain *);
221 #endif
222 static void scsi_tt_init(struct ncr_softc *);
223 static uint8_t get_tt_5380_reg(u_short);
224 static void set_tt_5380_reg(u_short, u_short);
225 static void scsi_tt_dmasetup(SC_REQ *, u_int, uint8_t);
226 static int tt_poll_edma(SC_REQ *);
227 static uint8_t *ptov(SC_REQ *, u_long*);
228 static int tt_get_dma_result(SC_REQ *, u_long *);
229
230 void scsi_tt_ienable(void);
231 void scsi_tt_idisable(void);
232 void scsi_tt_clr_ipend(void);
233
234 /*
235 * Define these too, so we can use them locally...
236 */
237 #define GET_TT_REG(rnum) SCSI_5380->scsi_5380[(rnum << 1) | 1]
238 #define SET_TT_REG(rnum,val) (SCSI_5380->scsi_5380[(rnum << 1) | 1] = val)
239
240 #ifdef NO_TTRAM_DMA
241 static int
tt_wrong_dma_range(SC_REQ * reqp,struct dma_chain * dm)242 tt_wrong_dma_range(SC_REQ *reqp, struct dma_chain *dm)
243 {
244
245 if (dm->dm_addr & 0xff000000) {
246 reqp->dr_flag |= DRIVER_BOUNCING;
247 return 1;
248 }
249 return 0;
250 }
251 #else
252 #define tt_wrong_dma_range(reqp, dm) 0
253 #endif
254
255 static void
scsi_tt_init(struct ncr_softc * sc)256 scsi_tt_init(struct ncr_softc *sc)
257 {
258
259 /*
260 * Enable SCSI-related interrupts
261 */
262 MFP2->mf_aer |= 0x80; /* SCSI IRQ goes HIGH!!!!! */
263
264 if (machineid & ATARI_TT) {
265 /* SCSI-DMA interrupts */
266 MFP2->mf_ierb |= IB_SCDM;
267 MFP2->mf_iprb = (uint8_t)~IB_SCDM;
268 MFP2->mf_imrb |= IB_SCDM;
269 } else if (machineid & ATARI_HADES) {
270 SCSI_DMA->s_hdma_ctrl = 0;
271
272 if (intr_establish(2, AUTO_VEC, 0,
273 (hw_ifun_t)ncr5380_drq_intr, NULL) == NULL)
274 panic("scsi_tt_init: Can't establish drq-interrupt");
275 } else
276 panic("scsi_tt_init: should not come here");
277
278 MFP2->mf_iera |= IA_SCSI; /* SCSI-5380 interrupts */
279 MFP2->mf_ipra = (uint8_t)~IA_SCSI;
280 MFP2->mf_imra |= IA_SCSI;
281
282 /*
283 * LWP: DMA transfers to TT-ram causes data to be garbled
284 * without notice on some TT-mainboard revisions.
285 * If programs generate mysterious Segmentations faults,
286 * try enabling NO_TTRAM_DMA.
287 */
288 #ifdef NO_TTRAM_DMA
289 printf(": DMA to TT-RAM is disabled!");
290 #endif
291 }
292
293 static uint8_t
get_tt_5380_reg(u_short rnum)294 get_tt_5380_reg(u_short rnum)
295 {
296
297 return SCSI_5380->scsi_5380[(rnum << 1) | 1];
298 }
299
300 static void
set_tt_5380_reg(u_short rnum,u_short val)301 set_tt_5380_reg(u_short rnum, u_short val)
302 {
303
304 SCSI_5380->scsi_5380[(rnum << 1) | 1] = val;
305 }
306
307 static inline void
scsi_tt_ienable(void)308 scsi_tt_ienable(void)
309 {
310
311 if (machineid & ATARI_TT)
312 single_inst_bset_b(MFP2->mf_imrb, IB_SCDM);
313 single_inst_bset_b(MFP2->mf_imra, IA_SCSI);
314 }
315
316 static inline void
scsi_tt_idisable(void)317 scsi_tt_idisable(void)
318 {
319
320 if (machineid & ATARI_TT)
321 single_inst_bclr_b(MFP2->mf_imrb, IB_SCDM);
322 single_inst_bclr_b(MFP2->mf_imra, IA_SCSI);
323 }
324
325 static inline void
scsi_tt_clr_ipend(void)326 scsi_tt_clr_ipend(void)
327 {
328 SCSI_DMA->s_dma_ctrl = 0;
329 GET_TT_REG(NCR5380_IRCV);
330 if (machineid & ATARI_TT)
331 MFP2->mf_iprb = (uint8_t)~IB_SCDM;
332 MFP2->mf_ipra = (uint8_t)~IA_SCSI;
333
334 /*
335 * Remove interrupts already scheduled.
336 */
337 rem_sicallback((si_farg)ncr_ctrl_intr);
338 rem_sicallback((si_farg)ncr_dma_intr);
339 }
340
341 static void
scsi_tt_dmasetup(SC_REQ * reqp,u_int phase,uint8_t mode)342 scsi_tt_dmasetup(SC_REQ *reqp, u_int phase, uint8_t mode)
343 {
344
345 if (PH_IN(phase)) {
346 SCSI_DMA->s_dma_ctrl = SD_IN;
347 if (machineid & ATARI_HADES)
348 SCSI_DMA->s_hdma_ctrl &= ~(SDH_BUSERR|SDH_EOP);
349 set_scsi_dma(SCSI_DMA->s_dma_ptr, reqp->dm_cur->dm_addr);
350 set_scsi_dma(SCSI_DMA->s_dma_cnt, reqp->dm_cur->dm_count);
351 SET_TT_REG(NCR5380_ICOM, 0);
352 SET_TT_REG(NCR5380_MODE, mode);
353 SCSI_DMA->s_dma_ctrl = SD_ENABLE;
354 SET_TT_REG(NCR5380_IRCV, 0);
355 } else {
356 SCSI_DMA->s_dma_ctrl = SD_OUT;
357 if (machineid & ATARI_HADES)
358 SCSI_DMA->s_hdma_ctrl &= ~(SDH_BUSERR|SDH_EOP);
359 set_scsi_dma(SCSI_DMA->s_dma_ptr, reqp->dm_cur->dm_addr);
360 set_scsi_dma(SCSI_DMA->s_dma_cnt, reqp->dm_cur->dm_count);
361 SET_TT_REG(NCR5380_MODE, mode);
362 SET_TT_REG(NCR5380_ICOM, SC_ADTB);
363 SET_TT_REG(NCR5380_DMSTAT, 0);
364 SCSI_DMA->s_dma_ctrl = SD_ENABLE|SD_OUT;
365 }
366 }
367
368 static int
tt_poll_edma(SC_REQ * reqp)369 tt_poll_edma(SC_REQ *reqp)
370 {
371 uint8_t dmstat, dmastat;
372 int timeout = 9000; /* XXX */
373
374 /*
375 * We wait here until the DMA has finished. This can be
376 * achieved by checking the following conditions:
377 * - 5380:
378 * - End of DMA flag is set
379 * - We lost BSY (error!!)
380 * - A phase mismatch has occurred (partial transfer)
381 * - DMA-controller:
382 * - A bus error occurred (Kernel error!!)
383 * - All bytes are transferred
384 * If one of the terminating conditions was met, we call
385 * 'dma_ready' to check errors and perform the bookkeeping.
386 */
387
388 scsi_tt_idisable();
389 for (;;) {
390 delay(20);
391 if (--timeout <= 0) {
392 ncr_tprint(reqp, "timeout on polled transfer\n");
393 reqp->xs->error = XS_TIMEOUT;
394 scsi_tt_ienable();
395 return 0;
396 }
397 dmstat = GET_TT_REG(NCR5380_DMSTAT);
398
399 if ((machineid & ATARI_HADES) && (dmstat & SC_DMA_REQ)) {
400 ncr5380_drq_intr(1);
401 dmstat = GET_TT_REG(NCR5380_DMSTAT);
402 }
403
404 dmastat = SCSI_DMA->s_dma_ctrl;
405 if (dmstat & (SC_END_DMA|SC_BSY_ERR|SC_IRQ_SET))
406 break;
407 if ((dmstat & SC_PHS_MTCH) == 0)
408 break;
409 if (dmastat & (SD_BUSERR|SD_ZERO))
410 break;
411 }
412 scsi_tt_ienable();
413 return 1;
414 }
415
416 /*
417 * Convert physical DMA address to a virtual address.
418 */
419 static uint8_t *
ptov(SC_REQ * reqp,u_long * phaddr)420 ptov(SC_REQ *reqp, u_long *phaddr)
421 {
422 struct dma_chain *dm;
423 uint8_t *vaddr;
424
425 dm = reqp->dm_chain;
426 vaddr = reqp->xdata_ptr;
427 for (; dm < reqp->dm_cur; dm++)
428 vaddr += dm->dm_count;
429 vaddr += (u_long)phaddr - dm->dm_addr;
430 return vaddr;
431 }
432
433 static int
tt_get_dma_result(SC_REQ * reqp,u_long * bytes_left)434 tt_get_dma_result(SC_REQ *reqp, u_long *bytes_left)
435 {
436 int dmastat, dmstat;
437 uint8_t *byte_p;
438 u_long leftover;
439
440 dmastat = SCSI_DMA->s_dma_ctrl;
441 dmstat = GET_TT_REG(NCR5380_DMSTAT);
442 leftover = get_scsi_dma(SCSI_DMA->s_dma_cnt);
443 byte_p = (uint8_t *)get_scsi_dma(SCSI_DMA->s_dma_ptr);
444
445 if (dmastat & SD_BUSERR) {
446 /*
447 * The DMA-controller seems to access 8 bytes beyond
448 * its limits on output. Therefore check also the byte
449 * count. If it's zero, ignore the bus error.
450 */
451 if (leftover != 0) {
452 ncr_tprint(reqp,
453 "SCSI-DMA buserror - accessing 0x%x\n", byte_p);
454 reqp->xs->error = XS_DRIVER_STUFFUP;
455 }
456 }
457
458 /*
459 * We handle the following special condition below:
460 * -- The device disconnects in the middle of a write operation --
461 * In this case, the 5380 has already pre-fetched the next byte from
462 * the DMA-controller before the phase mismatch occurs. Therefore,
463 * leftover is 1 too low.
464 * This does not always happen! Therefore, we only do this when
465 * leftover is odd. This assumes that DMA transfers are _even_! This
466 * is normally the case on disks and types but might not always be.
467 * XXX: Check if ACK is consistently high on these occasions LWP
468 */
469 if ((leftover & 1) &&
470 (dmstat & SC_PHS_MTCH) == 0 && PH_OUT(reqp->phase))
471 leftover++;
472
473 /*
474 * Check if there are some 'restbytes' left in the DMA-controller.
475 */
476 if ((machineid & ATARI_TT) &&
477 ((u_long)byte_p & 3) && PH_IN(reqp->phase)) {
478 uint8_t *p;
479 volatile uint8_t *q;
480
481 p = ptov(reqp, (u_long *)((u_long)byte_p & ~3));
482 q = SCSI_DMA->s_dma_res;
483 switch ((u_long)byte_p & 3) {
484 case 3: *p++ = *q++;
485 case 2: *p++ = *q++;
486 case 1: *p++ = *q++;
487 }
488 }
489 *bytes_left = leftover;
490 return (dmastat & (SD_BUSERR|SD_ZERO)) ? 1 : 0;
491 }
492
493 static uint8_t *dma_ptr;
494 void
ncr5380_drq_intr(int poll)495 ncr5380_drq_intr(int poll)
496 {
497 extern int *nofault;
498 label_t faultbuf;
499 int write;
500 u_long count;
501 volatile uint8_t *data_p = (volatile uint8_t *)(stio_addr + 0x741);
502
503 /*
504 * Block SCSI interrupts while emulating DMA. They come
505 * at a higher priority.
506 */
507 single_inst_bclr_b(MFP2->mf_imra, IA_SCSI);
508
509 /*
510 * Setup for a possible bus error caused by SCSI controller
511 * switching out of DATA-IN/OUT before we're done with the
512 * current transfer.
513 */
514 nofault = (int *)&faultbuf;
515
516 if (setjmp((label_t *) nofault)) {
517 u_long cnt, tmp;
518
519 PID("drq berr");
520 nofault = (int *)0;
521
522 /*
523 * Determine number of bytes transferred
524 */
525 cnt = (u_long)dma_ptr - get_scsi_dma(SCSI_DMA->s_dma_ptr);
526
527 if (cnt != 0) {
528 /*
529 * Update the DMA pointer/count fields
530 */
531 set_scsi_dma(SCSI_DMA->s_dma_ptr, (u_long)dma_ptr);
532 tmp = get_scsi_dma(SCSI_DMA->s_dma_cnt);
533 set_scsi_dma(SCSI_DMA->s_dma_cnt, tmp - cnt);
534
535 if (tmp > cnt) {
536 /*
537 * Still more to transfer
538 */
539 if (!poll)
540 single_inst_bset_b(MFP2->mf_imra,
541 IA_SCSI);
542 return;
543 }
544
545 /*
546 * Signal EOP to 5380
547 */
548 SCSI_DMA->s_hdma_ctrl |= SDH_EOP;
549 } else {
550 nofault = (int *)&faultbuf;
551
552 /*
553 * Try to figure out if the byte-count was
554 * zero because there was no (more) data or
555 * because the dma_ptr is bogus.
556 */
557 if (setjmp((label_t *) nofault)) {
558 /*
559 * Set the bus-error bit
560 */
561 SCSI_DMA->s_hdma_ctrl |= SDH_BUSERR;
562 }
563 __asm volatile ("tstb %0@(0)": : "a" (dma_ptr));
564 nofault = (int *)0;
565 }
566
567 /*
568 * Schedule an interrupt
569 */
570 if (!poll && (SCSI_DMA->s_dma_ctrl & SD_ENABLE))
571 add_sicallback((si_farg)ncr_dma_intr,
572 (void *)cur_softc, 0);
573
574 /*
575 * Clear DMA-mode
576 */
577 SCSI_DMA->s_dma_ctrl &= ~SD_ENABLE;
578 if (!poll)
579 single_inst_bset_b(MFP2->mf_imra, IA_SCSI);
580
581 return;
582 }
583
584 write = (SCSI_DMA->s_dma_ctrl & SD_OUT) ? 1 : 0;
585 #if DBG_PID
586 if (write) {
587 PID("drq (in)");
588 } else {
589 PID("drq (out)");
590 }
591 #endif
592
593 count = get_scsi_dma(SCSI_DMA->s_dma_cnt);
594 dma_ptr = (uint8_t *)get_scsi_dma(SCSI_DMA->s_dma_ptr);
595
596 /*
597 * Keep pushing bytes until we're done or a bus-error
598 * signals that the SCSI controller is not ready.
599 * NOTE: I tried some optimalizations in these loops,
600 * but they had no effect on transfer speed.
601 */
602 if (write) {
603 while (count--) {
604 *data_p = *dma_ptr++;
605 }
606 } else {
607 while (count--) {
608 *dma_ptr++ = *data_p;
609 }
610 }
611
612 /*
613 * OK. No bus error occurred above. Clear the nofault flag
614 * so we no longer short-circuit bus errors.
615 */
616 nofault = (int *)0;
617
618 /*
619 * Schedule an interrupt
620 */
621 if (!poll && (SCSI_DMA->s_dma_ctrl & SD_ENABLE))
622 add_sicallback((si_farg)ncr_dma_intr, (void *)cur_softc, 0);
623
624 /*
625 * Clear DMA-mode
626 */
627 SCSI_DMA->s_dma_ctrl &= ~SD_ENABLE;
628
629 /*
630 * Update the DMA 'registers' to reflect that all bytes
631 * have been transferred and tell this to the 5380 too.
632 */
633 set_scsi_dma(SCSI_DMA->s_dma_ptr, (u_long)dma_ptr);
634 set_scsi_dma(SCSI_DMA->s_dma_cnt, 0);
635 SCSI_DMA->s_hdma_ctrl |= SDH_EOP;
636
637 PID("end drq");
638 if (!poll)
639 single_inst_bset_b(MFP2->mf_imra, IA_SCSI);
640 }
641
642 #endif /* defined(TT_SCSI) */
643
644 #if defined(FALCON_SCSI) && !defined(TT_SCSI)
645
646 #define GET_5380_REG(rnum) get_falcon_5380_reg(rnum)
647 #define SET_5380_REG(rnum,val) set_falcon_5380_reg(rnum, val)
648 #define scsi_mach_init(sc) scsi_falcon_init(sc)
649 #define scsi_ienable() scsi_falcon_ienable()
650 #define scsi_idisable() scsi_falcon_idisable()
651 #define scsi_clr_ipend() scsi_falcon_clr_ipend()
652 #define scsi_ipending() scsi_falcon_ipending()
653 #define scsi_dma_setup(r,p,m) scsi_falcon_dmasetup(r, p, m)
654 #define wrong_dma_range(r,d) falcon_wrong_dma_range(r, d)
655 #define poll_edma(reqp) falcon_poll_edma(reqp)
656 #define get_dma_result(r, b) falcon_get_dma_result(r, b)
657 #define can_access_5380() falcon_can_access_5380()
658 #define emulated_dma() 0
659
660 #define fair_to_keep_dma() (!st_dmawanted())
661 #define claimed_dma() falcon_claimed_dma()
662 #define reconsider_dma() falcon_reconsider_dma()
663
664 #endif /* defined(FALCON_SCSI) && !defined(TT_SCSI) */
665
666 #if defined(FALCON_SCSI)
667
668 /*
669 * Prototype functions defined below
670 */
671 static void scsi_falcon_init(struct ncr_softc *);
672 static uint8_t get_falcon_5380_reg(u_short);
673 static void set_falcon_5380_reg(u_short, u_short);
674 static int falcon_wrong_dma_range(SC_REQ *, struct dma_chain *);
675 static void fal1_dma(u_int, u_int, SC_REQ *);
676 static void scsi_falcon_dmasetup(SC_REQ *, u_int, uint8_t);
677 static int falcon_poll_edma(SC_REQ *);
678 static int falcon_get_dma_result(SC_REQ *, u_long *);
679
680 int falcon_can_access_5380(void);
681 void scsi_falcon_clr_ipend(void);
682 void scsi_falcon_idisable(void);
683 void scsi_falcon_ienable(void);
684 int scsi_falcon_ipending(void);
685 int falcon_claimed_dma(void);
686 void falcon_reconsider_dma(void);
687
688 static void
scsi_falcon_init(struct ncr_softc * sc)689 scsi_falcon_init(struct ncr_softc *sc)
690 {
691
692 /*
693 * Enable disk related interrupts
694 */
695 MFP->mf_ierb |= IB_DINT;
696 MFP->mf_iprb = (uint8_t)~IB_DINT;
697 MFP->mf_imrb |= IB_DINT;
698 }
699
700 static uint8_t
get_falcon_5380_reg(u_short rnum)701 get_falcon_5380_reg(u_short rnum)
702 {
703
704 DMA->dma_mode = DMA_SCSI + rnum;
705 return DMA->dma_data;
706 }
707
708 static void
set_falcon_5380_reg(u_short rnum,u_short val)709 set_falcon_5380_reg(u_short rnum, u_short val)
710 {
711
712 DMA->dma_mode = DMA_SCSI + rnum;
713 DMA->dma_data = val;
714 }
715
716 static inline void
scsi_falcon_ienable(void)717 scsi_falcon_ienable(void)
718 {
719
720 single_inst_bset_b(MFP->mf_imrb, IB_DINT);
721 }
722
723 static inline void
scsi_falcon_idisable(void)724 scsi_falcon_idisable(void)
725 {
726
727 single_inst_bclr_b(MFP->mf_imrb, IB_DINT);
728 }
729
730 static inline void
scsi_falcon_clr_ipend(void)731 scsi_falcon_clr_ipend(void)
732 {
733
734 (void)get_falcon_5380_reg(NCR5380_IRCV);
735 rem_sicallback((si_farg)ncr_ctrl_intr);
736 }
737
738 static inline int
scsi_falcon_ipending(void)739 scsi_falcon_ipending(void)
740 {
741
742 if (connected && (connected->dr_flag & DRIVER_IN_DMA)) {
743 /*
744 * XXX: When DMA is running, we are only allowed to
745 * check the 5380 when DMA _might_ be finished.
746 */
747 if (MFP->mf_gpip & IO_DINT)
748 /* XXX: Actually: we're not allowed to check */
749 return 0;
750
751 /* LWP: 28-06, must be a DMA interrupt! should the
752 * ST-DMA unit be taken out of DMA mode?????
753 */
754 DMA->dma_mode = 0x90;
755
756 }
757 return get_falcon_5380_reg(NCR5380_DMSTAT) & SC_IRQ_SET;
758 }
759
760 static int
falcon_wrong_dma_range(SC_REQ * reqp,struct dma_chain * dm)761 falcon_wrong_dma_range(SC_REQ *reqp, struct dma_chain *dm)
762 {
763
764 /*
765 * Do not allow chains yet! See also comment with
766 * falcon_poll_edma() !!!
767 */
768 if (((dm - reqp->dm_chain) > 0) || (dm->dm_addr & 0xff000000)) {
769 reqp->dr_flag |= DRIVER_BOUNCING;
770 return 1;
771 }
772 /*
773 * Never allow DMA to happen on a Falcon when the transfer
774 * size is no multiple of 512. This is the transfer unit of the
775 * ST DMA-controller.
776 */
777 if (dm->dm_count & 511)
778 return 1;
779 return 0;
780 }
781
782 static int falcon_lock = 0;
783
784 static inline int
falcon_claimed_dma(void)785 falcon_claimed_dma(void)
786 {
787
788 if (falcon_lock != DMA_LOCK_GRANT) {
789 if (falcon_lock == DMA_LOCK_REQ) {
790 /*
791 * DMA access is being claimed.
792 */
793 return 0;
794 }
795 if (st_dmagrab((dma_farg)ncr_ctrl_intr, (dma_farg)run_main,
796 cur_softc, &falcon_lock, 1, NULL) == 0)
797 return 0;
798 }
799 return 1;
800 }
801
802 static inline void
falcon_reconsider_dma(void)803 falcon_reconsider_dma(void)
804 {
805
806 if (falcon_lock && (connected == NULL) && (discon_q == NULL)) {
807 /*
808 * No need to keep DMA locked by us as we are not currently
809 * connected and no disconnected jobs are pending.
810 */
811 rem_sicallback((si_farg)ncr_ctrl_intr);
812 st_dmafree(cur_softc, &falcon_lock);
813 }
814
815 if (!falcon_lock && (issue_q != NULL)) {
816 /*
817 * We must (re)claim DMA access as there are jobs
818 * waiting in the issue queue.
819 */
820 st_dmagrab((dma_farg)ncr_ctrl_intr, (dma_farg)run_main,
821 cur_softc, &falcon_lock, 0, NULL);
822 }
823 }
824
825 static void
fal1_dma(u_int dir,u_int nsects,SC_REQ * reqp)826 fal1_dma(u_int dir, u_int nsects, SC_REQ *reqp)
827 {
828
829 dir <<= 8;
830 st_dmaaddr_set((void *)reqp->dm_cur->dm_addr);
831 DMA->dma_mode = 0x90 | dir;
832 DMA->dma_mode = 0x90 | (dir ^ DMA_WRBIT);
833 DMA->dma_mode = 0x90 | dir;
834 DMA->dma_data = nsects;
835 delay(2); /* _really_ needed (Thomas Gerner) */
836 DMA->dma_mode = 0x10 | dir;
837 }
838
839 static void
scsi_falcon_dmasetup(SC_REQ * reqp,u_int phase,uint8_t mode)840 scsi_falcon_dmasetup(SC_REQ *reqp, u_int phase, uint8_t mode)
841 {
842 int nsects = reqp->dm_cur->dm_count / 512; /* XXX */
843
844 /*
845 * XXX: We should probably clear the fifo before putting the
846 * 5380 into DMA-mode.
847 */
848 if (PH_IN(phase)) {
849 set_falcon_5380_reg(NCR5380_ICOM, 0);
850 set_falcon_5380_reg(NCR5380_MODE, mode);
851 set_falcon_5380_reg(NCR5380_IRCV, 0);
852 fal1_dma(0, nsects, reqp);
853 } else {
854 set_falcon_5380_reg(NCR5380_MODE, mode);
855 set_falcon_5380_reg(NCR5380_ICOM, SC_ADTB);
856 set_falcon_5380_reg(NCR5380_DMSTAT, 0);
857 fal1_dma(1, nsects, reqp);
858 }
859 }
860
861 static int
falcon_poll_edma(SC_REQ * reqp)862 falcon_poll_edma(SC_REQ *reqp)
863 {
864 int timeout = 9000; /* XXX */
865
866 /*
867 * Because of the Falcon hardware, it is impossible to reach
868 * the 5380 while doing DMA-transfers. So we have to rely on
869 * the interrupt line to determine if DMA-has finished. the
870 * DMA-controller itself will never fire an interrupt. This means
871 * that 'broken-up' DMA transfers are not (yet) possible on the
872 * Falcon.
873 */
874 for (;;) {
875 delay(20);
876 if (--timeout <= 0) {
877 ncr_tprint(reqp, "Timeout on polled transfer\n");
878 reqp->xs->error = XS_TIMEOUT;
879 return 0;
880 }
881 if ((MFP->mf_gpip & IO_DINT) == 0)
882 break;
883 }
884 return 1;
885 }
886
887 static int
falcon_get_dma_result(SC_REQ * reqp,u_long * bytes_left)888 falcon_get_dma_result(SC_REQ *reqp, u_long *bytes_left)
889 {
890 int rv = 0;
891 int st_dmastat;
892 u_long bytes_done;
893
894 /*
895 * Select sector counter register first (See Atari docu.)
896 */
897 DMA->dma_mode = 0x90;
898 if (!(st_dmastat = DMA->dma_stat) & 0x01) {
899 /*
900 * Misc. DMA-error according to Atari...
901 */
902 ncr_tprint(reqp, "Unknown ST-SCSI error near 0x%x\n",
903 st_dmaaddr_get());
904 reqp->xs->error = XS_DRIVER_STUFFUP;
905 rv = 1;
906 }
907 /*
908 * Because we NEVER start DMA on the Falcon when the data size
909 * is not a multiple of 512 bytes, we can safely round down the
910 * byte count on writes. We need to because in case of a disconnect,
911 * the DMA has already prefetched the next couple of bytes.
912 * On read, these byte counts are an error. They are logged and
913 * should be handled by the mi-part of the driver.
914 * NOTE: We formerly did this by using the 'byte-count-zero' bit
915 * of the DMA controller, but this didn't seem to work???
916 * [lwp 29/06/96]
917 */
918 bytes_done = st_dmaaddr_get() - reqp->dm_cur->dm_addr;
919 if (bytes_done & 511) {
920 if (PH_IN(reqp->phase)) {
921 ncr_tprint(reqp, "Byte count on read not a multiple "
922 "of 512 (%ld)\n", bytes_done);
923 }
924 bytes_done &= ~511;
925 }
926 if ((*bytes_left = reqp->dm_cur->dm_count - bytes_done) == 0)
927 rv = 1;
928 return rv;
929 }
930
931 static int
falcon_can_access_5380(void)932 falcon_can_access_5380(void)
933 {
934
935 if (connected && (connected->dr_flag & DRIVER_IN_DMA) &&
936 (MFP->mf_gpip & IO_DINT))
937 return 0;
938 return 1;
939 }
940
941 #endif /* defined(FALCON_SCSI) */
942
943 #if defined(TT_SCSI) && defined(FALCON_SCSI)
944 /*
945 * Define some functions to support _both_ TT and Falcon SCSI
946 */
947
948 /*
949 * The prototypes first...
950 */
951 static void scsi_mach_init(struct ncr_softc *);
952
953 void scsi_ienable(void);
954 void scsi_idisable(void);
955 void scsi_clr_ipend(void);
956 int scsi_ipending(void);
957 void scsi_dma_setup(SC_REQ *, u_int, uint8_t);
958 int wrong_dma_range(SC_REQ *, struct dma_chain *);
959 int poll_edma(SC_REQ *);
960 int get_dma_result(SC_REQ *, u_long *);
961 int can_access_5380(void);
962
963 /*
964 * Register access will be done through the following 2 function pointers.
965 */
966 static uint8_t (*get_5380_reg)(u_short);
967 static void (*set_5380_reg)(u_short, u_short);
968
969 #define GET_5380_REG (*get_5380_reg)
970 #define SET_5380_REG (*set_5380_reg)
971
972 static void
scsi_mach_init(struct ncr_softc * sc)973 scsi_mach_init(struct ncr_softc *sc)
974 {
975
976 if (machineid & ATARI_FALCON) {
977 get_5380_reg = get_falcon_5380_reg;
978 set_5380_reg = set_falcon_5380_reg;
979 scsi_falcon_init(sc);
980 } else {
981 get_5380_reg = get_tt_5380_reg;
982 set_5380_reg = set_tt_5380_reg;
983 scsi_tt_init(sc);
984 }
985 }
986
987 static inline void
scsi_ienable(void)988 scsi_ienable(void)
989 {
990
991 if (machineid & ATARI_FALCON)
992 scsi_falcon_ienable();
993 else
994 scsi_tt_ienable();
995 }
996
997 static inline void
scsi_idisable(void)998 scsi_idisable(void)
999 {
1000
1001 if (machineid & ATARI_FALCON)
1002 scsi_falcon_idisable();
1003 else
1004 scsi_tt_idisable();
1005 }
1006
1007 static inline void
scsi_clr_ipend(void)1008 scsi_clr_ipend(void)
1009 {
1010
1011 if (machineid & ATARI_FALCON)
1012 scsi_falcon_clr_ipend();
1013 else
1014 scsi_tt_clr_ipend();
1015 }
1016
1017 static inline int
scsi_ipending(void)1018 scsi_ipending(void)
1019 {
1020
1021 if (machineid & ATARI_FALCON)
1022 return scsi_falcon_ipending();
1023 else
1024 return GET_TT_REG(NCR5380_DMSTAT) & SC_IRQ_SET;
1025 }
1026
1027 static inline void
scsi_dma_setup(SC_REQ * reqp,u_int phase,uint8_t mbase)1028 scsi_dma_setup(SC_REQ *reqp, u_int phase, uint8_t mbase)
1029 {
1030
1031 if (machineid & ATARI_FALCON)
1032 scsi_falcon_dmasetup(reqp, phase, mbase);
1033 else
1034 scsi_tt_dmasetup(reqp, phase, mbase);
1035 }
1036
1037 static inline int
wrong_dma_range(SC_REQ * reqp,struct dma_chain * dm)1038 wrong_dma_range(SC_REQ *reqp, struct dma_chain *dm)
1039 {
1040
1041 if (machineid & ATARI_FALCON)
1042 return falcon_wrong_dma_range(reqp, dm);
1043 else
1044 return tt_wrong_dma_range(reqp, dm);
1045 }
1046
1047 static inline int
poll_edma(SC_REQ * reqp)1048 poll_edma(SC_REQ *reqp)
1049 {
1050
1051 if (machineid & ATARI_FALCON)
1052 return falcon_poll_edma(reqp);
1053 else
1054 return tt_poll_edma(reqp);
1055 }
1056
1057 static inline int
get_dma_result(SC_REQ * reqp,u_long * bytes_left)1058 get_dma_result(SC_REQ *reqp, u_long *bytes_left)
1059 {
1060
1061 if (machineid & ATARI_FALCON)
1062 return falcon_get_dma_result(reqp, bytes_left);
1063 else
1064 return tt_get_dma_result(reqp, bytes_left);
1065 }
1066
1067 static inline int
can_access_5380(void)1068 can_access_5380(void)
1069 {
1070
1071 if (machineid & ATARI_FALCON)
1072 return falcon_can_access_5380();
1073 return 1;
1074 }
1075
1076 #define emulated_dma() ((machineid & ATARI_HADES) ? 1 : 0)
1077
1078 /*
1079 * Locking stuff. All turns into NOP's on the TT.
1080 */
1081 #define fair_to_keep_dma() \
1082 ((machineid & ATARI_FALCON) ? !st_dmawanted() : 1)
1083 #define claimed_dma() \
1084 ((machineid & ATARI_FALCON) ? falcon_claimed_dma() : 1)
1085 #define reconsider_dma() \
1086 do { \
1087 if (machineid & ATARI_FALCON) \
1088 falcon_reconsider_dma(); \
1089 } while (/* CONSTCOND */ 0)
1090 #endif /* defined(TT_SCSI) && defined(FALCON_SCSI) */
1091
1092 /**********************************************
1093 * Functions present for both TT and Falcon. *
1094 **********************************************/
1095 /*
1096 * Our autoconfig matching function
1097 */
1098 static int
machine_match(device_t parent,cfdata_t cf,void * aux,struct cfdriver * cd)1099 machine_match(device_t parent, cfdata_t cf, void *aux, struct cfdriver *cd)
1100 {
1101 static int we_matched = 0; /* Only one unit */
1102
1103 if (strcmp(aux, cd->cd_name) || we_matched)
1104 return 0;
1105
1106 we_matched = 1;
1107 return 1;
1108 }
1109
1110 /*
1111 * Bounce buffer (de)allocation. Those buffers are gotten from the ST-mem
1112 * pool. Allocation here is both contiguous and in the lower 16Mb of
1113 * the address space. Thus being DMA-able for all controllers.
1114 */
1115 static uint8_t *
alloc_bounceb(u_long len)1116 alloc_bounceb(u_long len)
1117 {
1118 void *tmp;
1119
1120 return (uint8_t *)alloc_stmem(len, &tmp);
1121 }
1122
1123 static void
free_bounceb(uint8_t * bounceb)1124 free_bounceb(uint8_t *bounceb)
1125 {
1126
1127 free_stmem(bounceb);
1128 }
1129
1130 /*
1131 * 5380 interrupt.
1132 */
1133 void
scsi_ctrl(int sr)1134 scsi_ctrl(int sr)
1135 {
1136
1137 if (GET_5380_REG(NCR5380_DMSTAT) & SC_IRQ_SET) {
1138 scsi_idisable();
1139 add_sicallback((si_farg)ncr_ctrl_intr, (void *)cur_softc, 0);
1140 }
1141 }
1142
1143 /*
1144 * DMA controller interrupt
1145 */
1146 void
scsi_dma(int sr)1147 scsi_dma(int sr)
1148 {
1149 SC_REQ *reqp;
1150
1151 if ((reqp = connected) && (reqp->dr_flag & DRIVER_IN_DMA)) {
1152 scsi_idisable();
1153 add_sicallback((si_farg)ncr_dma_intr, (void *)cur_softc, 0);
1154 }
1155 }
1156
1157 /*
1158 * Last but not least... Include the general driver code
1159 */
1160 #include <atari/dev/ncr5380.c>
1161