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 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 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 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 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 294 get_tt_5380_reg(u_short rnum) 295 { 296 297 return SCSI_5380->scsi_5380[(rnum << 1) | 1]; 298 } 299 300 static void 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 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 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 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 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 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 * 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 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 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 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 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 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 717 scsi_falcon_ienable(void) 718 { 719 720 single_inst_bset_b(MFP->mf_imrb, IB_DINT); 721 } 722 723 static inline void 724 scsi_falcon_idisable(void) 725 { 726 727 single_inst_bclr_b(MFP->mf_imrb, IB_DINT); 728 } 729 730 static inline 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 1116 alloc_bounceb(u_long len) 1117 { 1118 void *tmp; 1119 1120 return (uint8_t *)alloc_stmem(len, &tmp); 1121 } 1122 1123 static void 1124 free_bounceb(uint8_t *bounceb) 1125 { 1126 1127 free_stmem(bounceb); 1128 } 1129 1130 /* 1131 * 5380 interrupt. 1132 */ 1133 void 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 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
Indexes created Mon Sep 22 05:09:51 GMT 2025