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