home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / AHDI / AHDI603 / DMAREAD.S < prev    next >
Encoding:
Text File  |  2001-02-09  |  55.1 KB  |  1,922 lines
  1. .super
  2. ******************* Revision Control System *****************************
  3. *
  4. * $Author: apratt $
  5. * =======================================================================
  6. *
  7. * $Date: 1991/11/06 22:42:16 $
  8. * =======================================================================
  9. *
  10. * $Locker:  $
  11. * =======================================================================
  12. *
  13. * $Log: dmaread.s,v $
  14. * Revision 1.27  1991/11/06  22:42:16  apratt
  15. * Fixed a BIG OOPS: at qd0 the label 'sdelay' was wrong so that
  16. * the add of _hz_200 to d0 was INSIDE the loop.  Oops.  Fixed.
  17. *
  18. * Revision 1.26  1991/10/15  15:04:18  apratt
  19. * Fixed a bug in the caller of strcmp.
  20. *
  21. * Revision 1.24  1991/09/30  18:04:38  apratt
  22. * Previous version worked very badly.  One theory: Conner says that
  23. * you need a delay between Identify and Init Parameters.  When Minna
  24. * took out the Init Parameters call, she also took out the delay.
  25. * Well, hmm, maybe the delay is required between Identify and
  26. * ANYTHING ELSE.  So it's back.
  27. *
  28. * Revision 1.23  1991/09/30  16:45:06  apratt
  29. * New from Minna: checks both READY and BUSY waiting for the right values.
  30. * Seems some drives set READY before clearing BUSY.  Sigh.
  31. *
  32. * Revision 1.22  1991/09/13  17:45:58  apratt
  33. * Oops - the delay was supposed to be 500us, not 500ms.  Made it
  34. * two ticks, which is btw 5 and 10 ms.
  35. *
  36. * Revision 1.21  1991/09/13  00:46:52  apratt
  37. * Minna added yet another delay: Conner wants 0.5sec between
  38. * power up and the Identify command.
  39. *
  40. * Revision 1.20  1991/09/12  19:56:18  apratt
  41. * Changed to assemble IDE_AT for ALL MACHINES, now that there's no
  42. * distinction at assembly time between ST and STPLUS.
  43. *
  44. * Revision 1.19  1991/09/06  14:50:56  apratt
  45. * Changed all "ifne" to "if" and "ifeq" to "if !" and "endc" to "endif."
  46. *
  47. * Revision 1.18  91/08/21  11:18:56  apratt
  48. * Fixed two oopses: iderdy is now consistently _iderdy,
  49. * and undev is outside IDEAT conditionals.
  50. * 
  51. * Revision 1.17  91/08/20  13:22:25  minna
  52. * Added iderdy() to test if IDE drive is ready before 
  53. * it's being talked to.  If the drive does not become
  54. * ready in 5 sec., it's considered as an unknown device.
  55. * 
  56. * Revision 1.16  91/08/15  16:18:07  apratt
  57. * Added code for IDE to wait until ATASR shows READY before
  58. * doing anything else.  Also changed so IDE_AT is assembled for
  59. * all STPLUS versions; the bus error detection will take care
  60. * of failing out quick on those machines that don't really have
  61. * an IDE bus.
  62. * 
  63. * Revision 1.15  91/08/02  16:21:23  minna
  64. * Added delay between identify() and initparm(),
  65. * and reversed changes made earlier today.
  66. * 
  67. * Revision 1.14  91/08/02  15:07:10  minna
  68. * Added handling of final interrupt after data transfer
  69. * on IDE drive.
  70. * 
  71. * Revision 1.13  91/07/29  12:37:45  minna
  72. * _atread() and _atwrite modified to not use the
  73. * ATSC (sector count register) to count down on
  74. * multiple sectors read or write.  Some vendors
  75. * decrement the register too early.
  76. * 
  77. * To test if the IDE interface exists, instead of
  78. * reading from bAT (the data register), read from
  79. * ATASR (the alternate status register.)
  80. * 
  81. * Revision 1.12  91/03/27  12:36:36  apratt
  82. * Base address of IDE has moved to $F00000.  This code assumes that the base
  83. * address is on a longword boundary.  Added guards against missing IDE bus,
  84. * and against missing ACSI (bus error when accessing DMA chip).  This is
  85. * for prototype PADs only, and may go away soon.
  86. * 
  87. * Changed switches to SCSI and IDE_AT, which are set based on TT and STPAD at
  88. * the top of the file.
  89. * 
  90. * Revision 1.11  91/02/26  17:58:37  minna
  91. * Base address of IDE bus has been moved to $F00000.  Note that this code
  92. * relies on the base address of the IDE bus being on a longword boundary.
  93. * 
  94. * Revision 1.10  90/10/29  15:52:12  minna
  95. * Base address of IDE bus has been moved to $C00040 (long word boundary).
  96. * 
  97. * Revision 1.9  90/10/19  16:05:22  minna
  98. * Added code to handle drives on the IDE-AT bus.
  99. * 
  100. * Revision 1.8  90/08/03  13:22:48  apratt
  101. * TTOS FINAL RELEASE
  102. * 
  103. * Revision 1.7  90/03/06  16:09:16  apratt
  104. * Moved .globl _resetscsi into the TT conditional; otherwise
  105. * MAS thinks it's external, even though it's never used!
  106. * 
  107. * Revision 1.6  90/03/02  17:46:34  apratt
  108. * This rev is the source for the 3/1/90 ROM.
  109. * 
  110. * Revision 1.5  90/03/01  17:27:00  apratt
  111. * Checkin of Minna's changes, including adding better spin-up delays
  112. * and the dmawrite call.
  113. * 
  114. * Revision 1.4  89/09/22  16:42:55  apratt
  115. * THIS VERSION REQUIRES TURBO C'S "MAS" ASSEMBLER
  116. * No functional changes from previous revision, which is the last to
  117. * require Alcyon's AS68 assembler.
  118. * 
  119. * Revision 1.3  89/09/07  16:30:02  apratt
  120. * Added delay after (potentially) resetting ACSI DMA chip; see SLOWACSI
  121. * code in flop.b.
  122. * 
  123. * Revision 1.2  89/08/25  16:49:18  apratt
  124. * Moved lastacstm from text seg to bss.
  125. * 
  126. * Revision 1.1  89/08/25  16:45:32  apratt
  127. * Initial revision
  128. * 
  129. *
  130. * =======================================================================
  131. *
  132. * $Revision: 1.27 $
  133. * =======================================================================
  134. *
  135. * $Source: e:/tos/bios\RCS\dmaread.s,v $
  136. * =======================================================================
  137. *
  138. *************************************************************************
  139.  
  140. * TT and STPAD equates are in switches.s
  141.  
  142. .include "switches.s"
  143.  
  144. * The code you get in assembling this file depends on the switches SCSI and
  145. * IDE_AT.  For now (2/91), only TT has SCSI and all STPLUSes have IDE.
  146. *
  147. * Those STPLUS machines which use these ROMs but don't actually have an IDE
  148. * bus will still get the IDE code, but using it will fail right away
  149. * because it always probes for the IDE bus and returns if it doesn't exist.
  150. *
  151. * As of 9/91 we want One Rom To Rule Them All, so ALL machines have IDE_AT.
  152. *
  153.  
  154. SCSI        =    TT
  155. IDE_AT        =    1    ; Always! (AKP 9/91)
  156.  
  157. SPSCSI        =    SPARROW    ; 1: Sparrow SCSI
  158.  
  159. ;+
  160. ; DMAREAD(), DMAWRITE() - 
  161. ;    New XBIOS calls to read from or write to hard disk on the
  162. ; ACSI, SCSI or IDE-AT bus.  This is a low-level read/write which 
  163. ; does not do a lot of checking.  Amount of data requested on each 
  164. ; ACSI read or write MUST be smaller than or equal to 255 physical
  165. ; (512-byte) sectors.  On SCSI, all I/O are done by handshaking.  
  166. ; Amount of data requested on each IDE-AT read or write MUST be 
  167. ; smaller than or equal to 256 physical (512-byte) sectors.
  168. ;
  169. ; Jul-24-1989    ml.    Started this from AHDI 3.50 of Jul 24 1989.
  170. ; Aug-23-1989    ml.    Added in code to do hand-shake I/O, instead of
  171. ;            DMA.
  172. ; Dec-11-1989    ml.    Adjusted time-outs.
  173. ; Feb-08-1990    ml.    Updated according to corrections made to the
  174. ;            TT driver (DRIVER.PRG v3.63)
  175. ;            Renamed as dmarw() after adding code to handle
  176. ;            writes also.
  177. ; Feb-28-1990    ml.    Split dmarw() to become dmaread() and dmawrite()
  178. ;            as requested by AKP.  Modified time-out handling.
  179. ;            If system was up for less than UPTIME clicks, use
  180. ;            UPTIME as time-out counter rather than the regular
  181. ;            SC?TMOUT value.
  182. ; Mar-02-1990    ml.    Undid (again?!!) modifications made since Feb 28.
  183. ;            Will use regular SC?TMOUT values.  BIOS will keep
  184. ;            calling _dmaread() at boot time until the drive
  185. ;            responses, BIOS' time-out count expires, or when 
  186. ;            Bios receive a quit message from the user.
  187. ; Oct-16-1990    ml.    Added in code to handle drives on the IDE-AT bus
  188. ;            also.  The code comes from DRIVER.PRG v4.50 (dated
  189. ;            Oct 16 1990), and is slightly modified.
  190. ; Oct-29-1990    ml.    Base address of the IDE bus has been moved to
  191. ;            $C00040 (long word boundary).
  192. ; Feb-22-1991    ml.    Base address of the IDE bus has been moved to
  193. ;            $F00000 (long word boundary).
  194. ; Jul-29-1991    ml.    Do not use the IDE Sector Count Register 
  195. ;            to count down mulitiple sectors read or
  196. ;            write.  Some vendors (e.g. Conner and 
  197. ;            Seagate) seem to update this register 
  198. ;            too early, and every now and then, the
  199. ;            last sector of data would remain in the
  200. ;            internal sector buffer.  
  201. ;            
  202. ;            Code in ideread() and idewrite() are modified
  203. ;            not to use the IDE Sector Count Register.
  204. ;
  205. ;            To check if the IDE bus is there, read from
  206. ;            the alternate status register instead of the
  207. ;            data register.
  208. ;
  209. ; Aug-02-1991    ml.    Added handling of final interrupt from the
  210. ;            IDE drive after data transfer. (Routines that 
  211. ;            call readbuf() and wrtbuf() are modified).
  212. ;
  213. ; Aug-02-1991    ml.    Change again!  Conner now says there is no
  214. ;            final interrupt after data transfer, but need
  215. ;            a delay between the identify() and initparm().
  216. ;
  217. ; Aug-15-1991    ml.    Added a check to see if IDE drive is ready before
  218. ;            sending it the identify() command, by testing the
  219. ;            DRDY (driver ready) bit in the Alternate Status
  220. ;            Register.
  221. ;
  222. ; Aug-20-1991    ml.    Added iderdy() to check if an IDE drive is ready
  223. ;            or not, this includes the check for the existence 
  224. ;            of the slave drive (IDE unit 1.)
  225. ;
  226. ; Sep-12-1991    ml.    Added in yet another delay for IDE drive.  Conner
  227. ;            requires a 500us delay before calling identify()
  228. ;            after power on.
  229. ;
  230. ; Sep-24-1991    ml.    In order to accomodate the Conner CP-2024 (2.5"
  231. ;            IDE drive,) the readbuf() and wrtbuf() routines
  232. ;            need to do move.w instead of move.l to transfer
  233. ;            data.  A tower of 8 move.w is used to speed up
  234. ;            the transfer.
  235. ;
  236. ; Sep-25-1991    ml.    Extended time-out (>= 1.5s) for data hand-shake 
  237. ;            to account for slow SCSI devices (e.g. CDAR-505 
  238. ;            CD-ROM.)  The extended time-out is only needed 
  239. ;            between the end of command phase to the beginning 
  240. ;            of data    phase.  The code has the extended time-out 
  241. ;            for every byte of data to be hand-shaken, but this
  242. ;            should not affect performance because it should
  243. ;            not time-out between data bytes.
  244. ;
  245. ;            Modified _resetscsi() to clear the SCSI reset 
  246. ;            interrupt request (should anyone ever want to
  247. ;            use interrupts for watching the 5380) by reading 
  248. ;            from the 5380's reset error/interrupt register.
  249. ;
  250. ; Sep-26-1991    ml.    If a time-out occurs BEYOND the selection phase,
  251. ;            a SCSI RESET is done to clear the SCSI bus from
  252. ;            any odd state.
  253. ;
  254. ;            Deleted code which initializes IDE drive parameters.
  255. ;            Just use parameters returned by _identify().  So,
  256. ;            delay added between _identify() and _initparm() was
  257. ;            also deleted.
  258. ;
  259. ;            To take care of the bigger sector size (2K) of the
  260. ;            CD-ROM, the ACSI DMA counter is always set at the 
  261. ;            maximum of 255 512-byte blocks.  This basically 
  262. ;            disables the DMA counter and let the counter on 
  263. ;            the device determines when the transfer is finished.
  264. ;            This implies the maximum number of sectors that can
  265. ;            be transferred to or from the CD-ROM is 63.  This
  266. ;            limit should be enforced by the caller of _dmaread()
  267. ;            and _dmawrite().
  268. ;
  269. ; Sep-27-1991    ml.    Instead of just checking the ready bit in the IDEASR
  270. ;            in _iderdy(), check the entire byte for the value
  271. ;            0x50 (the ready status.)
  272. ;
  273. ; Sep-30-1991    ml.    Added delay in _fdone() and _qdone() to take care of
  274. ;            slow ACSI devices, for example the laser printer, to
  275. ;            guard against applications which call dmaread() or
  276. ;            dmawrite() on such devices.
  277. ;
  278. ;            Delay that was taken out with the _initparm() is
  279. ;            put back.  Conner drives probably needs that delay
  280. ;            between _identify() and any command!
  281. ;
  282. ; Oct-11-1991    ml.    Special-cased Conner CP2024 when getting current 
  283. ;            drive parameters.  Conner CP2024's current drive
  284. ;            parameters are not stored in the _identify() data.
  285. ;            
  286. ; Nov-06-1991    ml.    Big OOPS!!!  When delay was added in to take care of
  287. ;            slow ACSI devices, the label "sdelay" for the branch
  288. ;            accidentally includes the "add" instruction.  So, it
  289. ;            takes a long time before we exit the loop.
  290. ;-
  291.  
  292. .globl    _dmaread
  293. .globl    _dmawrite
  294.  
  295.  
  296. ; System variables
  297. flock        equ        $43e    ; FIFO lock variable
  298. _hz_200        equ        $4ba    ; system 200hz timer
  299.  
  300. ; For ACSI and SCSI drives
  301. READ        equ        $08        ; opcode for Read sectors
  302. WRITE        equ        $0a        ; opcode for Write sectors
  303. NCMD        equ        6        ; normal command length (6 bytes)
  304. MAXACSI        equ        7        ; highest ACSI unit#
  305. MAXSCSI        equ        15        ; highest SCSI unit#
  306.  
  307. ; For IDE-AT drives
  308. IDEREAD        equ        $20        ; opcode for Read sectors
  309. IDEWRITE    equ        $30        ; opcode for Write sectors
  310. IDENTIFY    equ        $ec        ; opcode for Identify Drive
  311. D_IDENTIFY  equ        2        ; delay between power on and identify() (500us)
  312. D_WORST        equ        2000    ; worst case delay (10s)
  313. IDERDY        equ        1000    ; delay to wait for IDE drive to be ready
  314. MAXIDE        equ        16        ; highest IDE-AT unit# (unit 0 ONLY)
  315.  
  316. ; Error codes to return to BIOS
  317. EUNDEV        equ        (-15)   ; UNknown DEVice
  318. EREADF        equ        (-11)   ; READ Fault
  319. EWRITF        equ        (-10)   ; WRITe Fault
  320.  
  321. ; Offsets for registers addressing on data bus
  322. REGBASE        equ        1        ; most are on odd part of data bus
  323. REGSTEP        equ        2        ; for regs that are on word boundaries
  324. REGLSTEP    equ        4        ; for regs that are on long word boundaries
  325.  
  326.  
  327. ;+
  328. ; Declarations
  329. ;-
  330. .bss
  331. lastacstm:    ds.l    1    ; controller last accessed time
  332. _cmdblk:    ds.b    10    ; command block
  333. rwflag:        ds.b    1    ; 0: read   1: write
  334. .even
  335.  
  336. .if IDE_AT
  337. sbuf:        ds.l    129    ; scratch buffer (must be on long word
  338.                 ;    boundary)
  339. .even
  340.  
  341. .endif
  342.  
  343. .text
  344.  
  345. ;+
  346. ; dmaread() - read from a DMA device.
  347. ; dmawrite() - write to a DMA device.
  348. ;
  349. ; LONG    sectnum        $4(sp).l
  350. ; WORD    count        $8(sp).w
  351. ; BYTE    *buf;        $a(sp).l    $b(sp)=high $c(sp)=mid $d(sp)=low
  352. ; WORD    pdev;        $e(sp).w
  353. ;
  354. ; Returns 0 if successful.
  355. ; Returns a negative number if failure: 
  356. ;    EUNDEV (-15L) if unknown device (bad dev number)
  357. ;    EREADF (-11L) if read failure
  358. ;    EWRITF (-10L) if write failure
  359. ;           (-1L)  if timed-out
  360. ;
  361. ; Comments:
  362. ;    ACSI, SCSI and IDE-AT drives are supported.
  363. ;-
  364.     .globl    _dmaread
  365. _dmaread:
  366.     move.b    #0,rwflag        ; rwflag = 0 => a read
  367.     move.w    #READ,d1        ; d1 = opcode for READ
  368.     bra.b    dmarw
  369.     
  370.     .globl    _dmawrite
  371. _dmawrite:
  372.     move.b    #1,rwflag        ; rwflag = 1 => a write
  373.     move.w    #WRITE,d1        ; d1 = opcode for WRITE
  374.     
  375. dmarw:
  376. .if IDE_AT
  377.     cmpi.w    #MAXIDE,$e(sp)        ; unit# > IDE-AT unit# 16?
  378. .else
  379. .if SCSI|SPSCSI
  380.     cmpi.w    #MAXSCSI,$e(sp)        ; unit# > SCSI unit# 8-15?
  381. .else
  382.     cmpi.w    #MAXACSI,$e(sp)        ; unit# > ACSI unit# 0-7?
  383. .endif
  384. .endif
  385.     bhi    undev            ; if so, return unknow device
  386.  
  387. .if IDE_AT
  388.     cmp.w    #MAXSCSI,$e(sp)        ; an IDE-AT unit?
  389.     bhi    ide0            ; if so, talk IDE-AT
  390. .endif
  391.                     ; else talk ACSI or SCSI
  392.     lea    _cmdblk,a0        ; a0 -> beginning of command block
  393.     move.b    d1,(a0)+        ; byte 0 = opcode
  394.     move.b    5(sp),(a0)+        ; byte 1 = msb of logical block addr
  395.     move.b    6(sp),(a0)+        ; byte 2 = logical block addr
  396.     move.b    7(sp),(a0)+        ; byte 3 = lsb of logical block addr
  397.     move.b    9(sp),(a0)+        ; byte 4 = transfer length (in blocks)
  398.     clr.b    (a0)            ; byte 5 = control byte
  399.     move.w    $e(sp),d0        ; d0 = physical unit number
  400.     moveq    #NCMD,d2        ; d2 = length of command
  401.     movea.l    $a(sp),a0        ; a0 = buffer
  402.     tst.b    rwflag            ; read or write?
  403.     bne.b    rw0            ; it's a write
  404.     bsr    _dorcmd            ; send a receive data command
  405.     bra    rw1
  406. rw0:    bsr    _dowcmd            ; send a write data command
  407.  
  408. .if IDE_AT
  409.     bra    rw1            ; branch will take place for 
  410.                     ;    non-IDE drives
  411. *
  412. * Before doing anything with the IDE bus, make sure it's there.
  413. * (The label noide is before at just because it fits better.)
  414. *
  415.  
  416. noide:    move.l    a1,sp            ; got the bus error on IDEASR;
  417.     move.l    a0,$8            ; restore vector & sp, return EUNDEV
  418.     bra    undev
  419.  
  420. ide0:    move.l    $8,a0
  421.     move.l    sp,a1
  422.     move.l    #noide,$8
  423.     tst.b    IDEASR            ; read a register to probe for IDE bus
  424.     move.l    a1,sp            ; hey! no bus error!
  425.     move.l    a0,$8            ; restore vector & sp and continue.
  426.  
  427.     move.b    $f(sp),d0        ; IDE unit#
  428.     bsr    _iderdy            ; wait for drive to be ready
  429.     beq    undev            ; if drive never gets ready, return
  430.                     ;   with unknown device
  431.                     ; else
  432.     move.l    #D_IDENTIFY,d0        ; delay required by Conner drives
  433.     add.l    _hz_200,d0        ;  between power on and identify()
  434. ide1:    cmp.l    _hz_200,d0
  435.     bcc.b    ide1
  436.  
  437.     pea    sbuf            ; scratch buffer for drive parameters
  438.     move.w    $12(sp),-(sp)        ; IDE unit#
  439.     bsr    _identify        ; identify()
  440.     addq.w    #6,sp            ; clean up stack
  441.     tst.w    d0            ; successful?
  442.     bmi    rwend            ; if timed-out, return
  443.     bne    rw2            ; if error, return with error code
  444.                     ; else can do read or write
  445.     move.l    #D_IDENTIFY,d0        ; delay required by Conner drives
  446.     add.l    _hz_200,d0        ;  between identify() and r/w
  447. ide4:    cmp.l    _hz_200,d0
  448.     bcc.b    ide4
  449.  
  450.     pea    sbuf            ; beginning of _identify() data
  451.     bsr    _gcparm            ; get drive current parameters
  452.     addq    #4,sp            ; clean up stack
  453.  
  454.     move.w    $e(sp),-(sp)        ; physical unit #
  455.     move.l    $c(sp),-(sp)        ; buffer
  456.     move.w    $e(sp),-(sp)        ; count
  457.     move.l    $c(sp),-(sp)        ; logical block address
  458.     move.w    d2,-(sp)        ; # sectors per track
  459.     move.w    d1,-(sp)        ; # data heads
  460.     tst.b    rwflag            ; read or write?
  461.     bne.b    ide2            ; (write)
  462.     bsr    _ideread        ; read sectors
  463.     bra.b    ide3
  464. ide2:    bsr    _idewrite        ; write sectors
  465. ide3:    adda    #16,sp            ; clean up stack
  466. .endif    
  467. rw1:    
  468. .if    SCSI
  469.     move.w    sr,-(sp)        ; go to IPL 7
  470.     ori    #$700,sr        ; no interrupts right now please
  471.     movec    cacr,d1            ; d1 = (cache control register)
  472.     ori.w    #$0808,d1        ; dump both the I and D cache
  473.     movec    d1,cacr            ; update cache control register
  474.     move.w    (sp)+,sr        ; restore interrupt state
  475. .endif
  476.     tst.w    d0            ; successful?
  477.     ble.b    rwend            ; if no error or timed-out, return
  478.                     ; else
  479. rw2:    moveq    #EREADF,d0        ; assume it's a read error
  480.     tst.b    rwflag            ; read or write?
  481.     beq.b    rwend            ; if read, done
  482.     moveq    #EWRITF,d0        ; else, it's a write error
  483. rwend:    rts
  484.  
  485. undev:    moveq    #EUNDEV,d0
  486.     bra.b    rwend
  487.  
  488. ;+++++++++++++++++++++++++++++++;
  489. ;                ;
  490. ;    ACSI and SCSI specific    ;
  491. ;                ;
  492. ;+++++++++++++++++++++++++++++++;
  493.  
  494. ;+
  495. ; dorcmd() - send a command which will receive data from the target
  496. ;
  497. ; Passed:
  498. ;    d0.w = physical unit number
  499. ;    d2.w = command length (NCMD or LCMD)
  500. ;    a0.l = buffer address
  501. ;-
  502. _dorcmd:
  503. .if SCSI
  504.     cmp.w    #MAXACSI,d0        ; unit# > ACSI unit# 0 - 7?
  505.     bls.b    rcacsi            ; if not, it's an ACSI device
  506.     bsr    _rcvscsi        ; else, it's a SCSI device
  507.     rts
  508. .else
  509. .if SPSCSI
  510.     bsr    _rcvspscsi
  511.     rts
  512. .endif
  513. .endif
  514.  
  515. rcacsi:    bsr    _rcvacsi        ; it's an ACSI device
  516.     rts
  517.  
  518.  
  519. ;+
  520. ; dowcmd() - send a command which will write data to the target
  521. ;
  522. ; Passed:
  523. ;    d0.w = physical unit number
  524. ;    d2.w = command length (NCMD or LCMD)
  525. ;    a0.l = buffer address
  526. ;-
  527. _dowcmd:
  528. .if    SCSI
  529.     cmp.w    #MAXACSI,d0        ; unit# > ACSI unit# 0 - 7?
  530.     bls.b    wracsi            ; if not, it's an ACSI device
  531.     bsr    _wrtscsi        ; else, it's a SCSI device
  532.     rts
  533. .else
  534. .if SPSCSI
  535.     bsr    _wrtspscsi
  536.     rts
  537. .endif
  538. .endif
  539. wracsi:    bsr    _wrtacsi        ; it's an ACSI device
  540.     rts
  541.  
  542.     
  543.  
  544. ;+++++++++++++++++++++++++++++++;
  545. ;                ;
  546. ;    ACSI specific        ;
  547. ;                ;
  548. ;+++++++++++++++++++++++++++++++;
  549.  
  550. ;+
  551. ;  Hardware definitions for ACSI
  552. ;-
  553. WDC        equ    $ffff8604
  554. WDL        equ    $ffff8606
  555. WDCWDL        equ    WDC        ; used for long writes
  556. XWDL        equ    WDL-WDC        ; offset from wdc to wdl
  557.  
  558. DMAHI        equ    $ffff8609
  559. DMAMID        equ    DMAHI+2
  560. DMALOW        equ    DMAMID+2
  561. GPIP        equ    $fffffa01
  562.  
  563.  
  564. ;+
  565. ;  Tunable (delay) values for ACSI
  566. ;-
  567. ACLTMOUT    equ    600        ; long time-out (3 s)
  568. ACSTMOUT    equ    20        ; short time-out (100 ms)
  569.  
  570.  
  571. ;+
  572. ; LONG _qdone() - Wait for command byte handshake
  573. ; LONG _fdone() - Wait for operation complete
  574. ; Passed:    nothing
  575. ;
  576. ; Returns:    EQ: no time-out
  577. ;        MI: time-out condition
  578. ;
  579. ; Uses:        D0
  580. ;
  581. ;-
  582. _fdone:    move.l    #ACLTMOUT,d0
  583.     bra.b    qd0
  584.  
  585. _qdone:    move.l    #ACSTMOUT,d0
  586.  
  587. qd0:    move.l    d0,-(sp)        ; save timeout value
  588.     moveq    #2,d0            ; busy-wait delay for slow ACSI
  589.     add.l    _hz_200,d0        ; minimum 20 microsec.
  590. sdelay:    cmp.l    _hz_200,d0
  591.     bge.b    sdelay
  592.     move.l    (sp)+,d0        ; restore timeout value
  593.  
  594.     add.l    _hz_200,d0
  595. qd1:    cmp.l    _hz_200,d0        ; time-out?
  596.     bcs.b    qdq            ; (i give up, return NE)
  597.     btst    #5,GPIP            ; interrupt?
  598.     bne.b    qd1            ; (not yet)
  599.  
  600.     moveq    #0,d0            ; return EQ (no time-out)
  601.     rts
  602.  
  603. qdq:    moveq    #-1,d0
  604.     rts
  605.  
  606.  
  607. ;+
  608. ; Wait for end of SASI command
  609. ;
  610. ; Passed:    d1 value to be written to wdl
  611. ;
  612. ; Returns:    EQ: success (error code in D0.W)
  613. ;        MI: time-out (-1 in D0.W)
  614. ;        NE: failure (SASI error code in D0.W)
  615. ;
  616. ; Uses:        d0
  617. ;-
  618. _endcmd:
  619.     bsr    _fdone            ; wait for operation complete
  620.     bmi.b    endce            ; (timed-out, so complain)
  621.  
  622. .if    SCSI                ; dump D cache
  623.     move.w    sr,-(sp)        ; go to IPL 7
  624.     ori.w    #$700,sr        ; no interrupts right now kudasai
  625.     movec    cacr,d0            ; d0 = (cache control register)
  626.     ori.w    #$800,d0        ; dump the D cache
  627.     movec    d0,cacr            ; update cache control register
  628.     move.w    (sp)+,sr        ; restore interrupt state
  629. .endif
  630.  
  631.     move.w    d1,WDL
  632.     move.w    WDC,d0            ; get the result
  633.     and.w    #$00ff,d0        ; (clean it up) if non-0 should do a
  634.                     ; RequestSense command to learn more
  635. endce:    move.l    _hz_200,lastacstm    ; update controller last accessed time
  636.     addq.l    #2,lastacstm        ; lastacstm = _hz_200 + 2;
  637.     rts                
  638.  
  639.  
  640. ;+
  641. ;  Handle command time-out;
  642. ;  Unlock DMA chip and return completion status;
  643. ;-
  644. _hdone:    move.w    #$80,WDL    ; Landon's code seems to presume we put 
  645.                 ;  $80 there
  646.     sf    flock        ; NOW, signal that we are done
  647.     rts
  648.  
  649.  
  650. ;+
  651. ; delay()
  652. ;    5 - 10ms kludge delay for message byte sent back by controller.
  653. ;-
  654. _delay:    move.l    d0,-(sp)        ; preserve d0
  655.     move.l    lastacstm,d0        ; d0 = controller last accessed time
  656. wait:    cmp.l    _hz_200,d0        ; while (_hz_200 <= lastacstm)
  657.     bcc.b    wait            ;    wait()
  658.     move.l    (sp)+,d0        ; restore d0
  659.     rts
  660.  
  661.  
  662. ;+
  663. ; rcvacsi() - send a ACSI command which receives data from target.
  664. ;
  665. ; Passed:
  666. ;    d0.w = physical unit number
  667. ;    d2.w = command length (NCMD or LCMD)
  668. ;    a0.l = buffer address
  669. ;-
  670. _rcvacsi:
  671.  
  672. * check to see if the ACSI bus actually exists! Needed for prototype PADs
  673.     move.l    $8,a1
  674.     move.l    sp,a2
  675.     move.l    #noacsi,$8
  676.     tst.w    WDL            ; harmless or bus erorr
  677.     move.l    a1,$8            ; no bus error - restore & continue
  678.     move.l    a2,sp
  679.  
  680.     st    flock            ; lock FIFO
  681.     bsr    _delay            ; delay if necessary
  682.     movea.l    #WDC,a1            ; a1 = pointer to DMA chip
  683.  
  684.     bsr    setadma            ; set DMA pointer
  685.     move.w    #$190,XWDL(a1)    ;WDL    ; toggle DMA chip to direction
  686.     bsr    rstdelay        ; delay
  687.     move.w    #$090,XWDL(a1)    ;WDL    ;  for receiving data
  688.     bsr    rstdelay        ; delay
  689.     bsr    setacnt            ; set DMA count
  690.  
  691.     lea    _cmdblk,a0        ; a0 = address of command block
  692.     moveq    #0,d1            ; direction of DMA is IN
  693.     bsr    sblkacsi        ; send the command block
  694. raend:    bra    _hdone            ; cleanup after IRQ
  695.  
  696.  
  697. ;+
  698. ; wrtacsi() - send an ACSI command which will write data to the target
  699. ;
  700. ; Passed:
  701. ;    d0.w = physical unit number
  702. ;    d2.w = command length (NCMD or LCMD)
  703. ;    a0.l = buffer address
  704. ;-
  705. _wrtacsi:
  706.  
  707. * check to see if the ACSI bus actually exists! Needed for prototype PADs
  708.     move.l    $8,a1
  709.     move.l    sp,a2
  710.     move.l    #noacsi,$8
  711.     tst.w    WDC            ; harmless or bus erorr
  712.     move.l    a1,$8            ; no bus error - restore & continue
  713.     move.l    a2,sp
  714.  
  715.     st    flock            ; lock FIFO
  716.     bsr    _delay
  717.     movea.l    #WDC,a1            ; a1 = pointer to DMA chip
  718.  
  719.     bsr    setadma            ; set DMA pointer
  720.     move.w    #$90,XWDL(a1)    ;WDL    ; toggle DMA chip for "send"
  721.     bsr    rstdelay        ; delay 
  722.     move.w    #$190,XWDL(a1)    ;WDL
  723.     bsr    rstdelay        ; delay
  724.     bsr    setacnt            ; set DMA count
  725.     
  726.     move.l    #$0100,d1        ; d1 = direction of DMA is OUT
  727.     bsr    sblkacsi        ; send the command block
  728.  
  729. waend:    bra    _hdone            ; cleanup after IRQ
  730.  
  731. * You get to this label if there is a bus error when probing for
  732. * the ACSI bus: it's meant for prototype PADs, which don't
  733. * have an ACSI DMA chip.
  734.  
  735. noacsi:    moveq.l    #-15,d0            ; return EUNDEV
  736.     move.l    a2,sp
  737.     move.l    a1,$8
  738.     rts
  739.  
  740. ;+
  741. ; sblkacsi() - send command block
  742. ;
  743. ; Passed:
  744. ;    d0.w = physical unit number
  745. ;    d1.l = direction of DMA ($0000 for IN or $0100 for OUT)
  746. ;    d2.w = command length (NCMD or LCMD)
  747. ;    a1.l = pointer to DMA chip
  748. ;
  749. ; Returns:
  750. ;    d0.l =  0 if successful
  751. ;    d0.l = -1 if time-out
  752. ;
  753. ; Trashes:
  754. ;    d0, d1, d2, a2
  755. ;-
  756. sblkacsi:
  757.     move.b    #$88,d1            ; next byte is the opcode
  758.     move.w    d1,XWDL(a1)    ;WDL
  759.  
  760.     move.b    #$8a,d1            ; following bytes are operands
  761.     lea    _cmdblk,a2        ; a2 = address of command block
  762.                     ; integrate unit # into cmd blk
  763.     lsl.b    #5,d0            ; shift unit number into place
  764.     or.b    d0,(a2)            ; first command byte = unit # | opcode
  765.                     ; control byte is sent seperately
  766.     subq.w    #2,d2            ; and dbra likes one less 
  767. sa1:    swap    d1            ; d1.hw = operand
  768.     move.b    (a2)+,d1        ; d1.lw = tells controller next byte
  769.     swap    d1            ;      is an operand
  770.     move.l    d1,(a1)        ;WDCWDL
  771.     bsr    _qdone
  772.     bmi.b    sbaend            ; if time-out, returns
  773.     dbra    d2,sa1            ; else send rest of command block
  774.  
  775.     move.w    d1,XWDL(a1)    ;WDL    ; get ready to send control byte
  776.     move.b    #0,d1            ; signal sending control byte
  777.     swap    d1            ; d1.hw = control byte
  778.     move.b    (a2),d1            ; d1.lw = tells controller it's end
  779.     swap    d1            ;      of command
  780.     move.l    d1,(a1)            ; send it
  781.  
  782.     move.b    #$8a,d1            ; d1 = wdl value
  783.     bsr    _endcmd            ; wait for command completion
  784. sbaend: rts                ; heading home
  785.  
  786.  
  787. ;+
  788. ; setadma() - set the ACSI DMA pointer
  789. ;
  790. ; Passed:
  791. ;    a0.l = buffer address
  792. ;-
  793. setadma:
  794.     move.l    a0,-(sp)        ; move it on stack
  795.     move.b    3(sp),DMALOW        ; set low-byte of address
  796.     move.b    2(sp),DMAMID        ; set mid-byte of address
  797.     move.b    1(sp),DMAHI        ; set high-byte of address
  798.     addq.l    #4,sp            ; clean up stack
  799.     rts
  800.  
  801.  
  802. ;+
  803. ; setacnt() - set the ACSI DMA counter
  804. ;
  805. ; Comments:
  806. ;    26-Sep-1991 ml    DMA counter is always set at the maximum 
  807. ; (255 sectors) to force the use of the device counter.
  808. ;
  809. ; Passed:
  810. ;    a1.l = pointer to DMA chip
  811. ;-
  812. setacnt:
  813.     move.w    #$ff,(a1)        ;WDC    ; set DMA count
  814.     rts
  815.  
  816.  
  817. ;+
  818. ; Rstdelay()
  819. ;    After talking to the DMA chip in a way that may reset it, 
  820. ; we need a 8 8Mhz clocks (ie. 1 microsec) delay, before we can
  821. ; talk to the chip again.
  822. ;-
  823. rstdelay:
  824.     tst.b    GPIP            ; delay for 1 microsec
  825.     tst.b    GPIP            ; this amounts to 16 16Mhz clocks
  826.     tst.b    GPIP
  827.     tst.b    GPIP
  828.     rts
  829.  
  830.  
  831. .if    SCSI
  832.  
  833. ;+++++++++++++++++++++++++++++++;
  834. ;                ;
  835. ;    SCSI specific        ;
  836. ;                ;
  837. ;+++++++++++++++++++++++++++++++;
  838.  
  839. .globl    _resetscsi
  840.  
  841. ; SCSI Interface (NCR 5380) for READ operations
  842. bSCSI    equ    $FFFF8780+REGBASE
  843. SCSIDB    equ    bSCSI+($00*REGSTEP)    ; current SCSI data bus
  844. SCSIICR    equ    bSCSI+($01*REGSTEP)    ; initiator command register
  845. SCSIMR    equ    bSCSI+($02*REGSTEP)    ; mode register
  846. SCSITCR    equ    bSCSI+($03*REGSTEP)    ; target command register
  847. SCSICR    equ    bSCSI+($04*REGSTEP)    ; current SCSI control register
  848. SCSIDSR    equ    bSCSI+($05*REGSTEP)    ; DMA status register
  849. SCSIIDR    equ    bSCSI+($06*REGSTEP)    ; input data register
  850. SCSIREI    equ    bSCSI+($07*REGSTEP)    ; reset error / interrupt
  851.  
  852. ; SCSI Interface (NCR 5380) for WRITE operations
  853. SCSIODR    equ    bSCSI+($00*REGSTEP)    ; output data register
  854. ;SCSIICR    bSCSI+($01*REGSTEP)    ; initiator command register
  855. ;SCSIMR        bSCSI+($02*REGSTEP)    ; mode register
  856. ;SCSITCR    bSCSI+($03*REGSTEP)    ; target command register
  857. SCSIISR    equ    bSCSI+($04*REGSTEP)    ; ID select register
  858. SCSIDS    equ    bSCSI+($05*REGSTEP)    ; start DMA send
  859. SCSIDTR    equ    bSCSI+($06*REGSTEP)    ; start DMS target receive
  860. SCSIDIR    equ    bSCSI+($07*REGSTEP)    ; start DMA initiator receive
  861.  
  862. ; SCSI DMA Controller
  863. SDMACTL        equ    $FFFF8714    ; WORD
  864.  
  865. ;+
  866. ; Tunable (delay) values (in number of _hz_200 ticks) for SCSI
  867. ;-
  868. SCLTMOUT    equ    301        ; long time-out (at least 1.5 s)
  869. SCSTMOUT    equ    51        ; short time-out (at least 250 ms)
  870.  
  871. ;+
  872. ; rcvscsi() - send a SCSI command which receives data back.
  873. ;
  874. ; Passed:
  875. ;    d0.w = physical unit number
  876. ;    d2.w = command length (NCMD or LCMD)
  877. ;    a0.l = buffer address
  878. ;-
  879. _rcvscsi:
  880.     move.l    a0,-(sp)        ; save buffer address
  881.     andi.w    #7,d0            ; mask off the flags to get unit num
  882.     bsr    sblkscsi        ; send command block
  883.     movea.l    (sp)+,a0        ; restore buffer address
  884.     tst.w    d0            ; successful?
  885.     bmi.b    rsend            ; if not successful, return
  886.  
  887.     movea.l    a0,a1            ; a1 -> buffer to read into
  888.     movea.l    #bSCSI,a2        ; a2 -> 5380
  889.     move.b    #1,SCSITCR        ; set data in phase
  890.     move.b    SCSIREI,d0        ; clear potential interrupt
  891.  
  892.     ;+
  893.     ; 25-Sep-91 ml.    The long time-out is used instead of the short
  894.     ;        time-out to accomodate slow SCSI devices.
  895.     ;-
  896. rs0:    bsr    setscltmout        ; set up time-out
  897.     bsr    w4req            ; wait for REQ to come
  898.     bmi.b    rsend            ; if timed out, returns
  899.     btst    #3,5*REGSTEP(a2)    ; still in data in phase?
  900.     beq    w4stat            ; no, go get status
  901.     move.b    (a2),(a1)+        ; read the data byte
  902.     bsr    doack
  903.     bra.b    rs0            ; do next byte
  904. rsend:    bsr    _resetscsi        ; timed-out, reset SCSI bus
  905.     rts
  906.  
  907.  
  908. ;+
  909. ; wrtscsi() - send a SCSI command which will write data to the target
  910. ;
  911. ; Passed:
  912. ;    d0.w = physical unit number
  913. ;    d2.w = command length (NCMD or LCMD)
  914. ;    a0.l = buffer address
  915. ;-
  916. _wrtscsi:
  917.     andi.w    #7,d0            ; mask off the flags to get unit num
  918.     move.l    a0,-(sp)        ; save beginning buffer address
  919.     move.w    d2,-(sp)        ; save command length
  920.     bsr    sblkscsi        ; send command block
  921.     move.w    (sp)+,d2        ; restore command length
  922.     move.l    (sp)+,a0        ; a0 = where DMA ends
  923.     tst.w    d0            ; successful?
  924.     bmi.b    wsend            ; if failure, return
  925.  
  926.     movea.l    a0,a1            ; a1 -> buffer to write from
  927.     movea.l    #bSCSI,a2        ; a2 -> 5380
  928.     move.b    #0,SCSITCR        ; set data out phase
  929.     move.b    SCSIREI,d0        ; clear potential interrupt
  930.  
  931.     ;+
  932.     ; 25-Sep-91 ml.    The long time-out is used instead of the short
  933.     ;        time-out to accomodate slow SCSI devices.
  934.     ;-
  935. ws0:    bsr    setscltmout
  936.     bsr    w4req            ; wait for REQ to come
  937.     bmi.b    wsend            ; if timed out, returns
  938.     btst    #3,5*REGSTEP(a2)    ; still in data out phase?
  939.     beq    w4stat            ; no, go get status
  940.     move.b    (a1)+,(a2)        ; write the data byte
  941.     bsr    doack
  942.     bra.b    ws0            ; do next byte
  943. wsend:    bsr    _resetscsi        ; timed-out, reset SCSI bus
  944.     rts
  945.  
  946.  
  947.  
  948. ;+
  949. ; sblkscsi() - send command block
  950. ;
  951. ; Passed:
  952. ;    d0.w = physical unit number
  953. ;    d2.w = command length (NCMD or LCMD)
  954. ;
  955. ; Returns:
  956. ;    d0.l =  0 if successful
  957. ;    d0.l = -1 if time-out
  958. ;-
  959. sblkscsi:
  960.     move.l    d2,-(sp)        ; save command length
  961.     move.w    d0,-(sp)        ; physical unit #
  962.     bsr    selscsi            ; select the unit
  963.     addq    #2,sp            ; clean up stack
  964.     move.l    (sp)+,d2        ; restore command length
  965.     tst.w    d0            ; selection successful?
  966.     bmi.b    sbsend            ; if timed out, return
  967.                     ; else proceed
  968.     move.b    #2,SCSITCR        ; assert C/D
  969.     move.b    #1,SCSIICR        ; assert data bus
  970.  
  971.     lea    _cmdblk,a1        ; a1 -> command block
  972.     subq.w    #1,d2            ; dbra likes one less
  973.  
  974.     bsr    setscstmout        ; set a short time-out
  975. ss1:    move.b    (a1)+,d0        ; d0.b = byte to be sent
  976.     bsr    hshake            ; write that byte
  977.     tst.w    d0
  978.     bmi.b    sbsend            ; if timed-out, returns
  979.     dbra    d2,ss1            ; until whole command block is sent
  980.     moveq    #0,d0            ; all operations successful
  981. sbsend: rts                ; heading home
  982.  
  983.  
  984. ;+
  985. ; BOOLEAN selscsi(SCSIUnit) 
  986. ; WORD SCSIUnit;
  987. ;-
  988. selscsi:
  989.     bsr    setscstmout        ; set up a short time-out
  990. sels0:    btst    #6,SCSICR        ; STILL busy from last time?
  991.     beq.b    sels1            ; if not, it's available
  992.     cmp.l    (a0),d1            ; time-out?
  993.     bhi.b    sels0            ; not yet, wait some more
  994.     bra.b    sels4            ; else, return error
  995.  
  996. sels1:    move.b    #0,SCSITCR        ; data out phase
  997.     move.b    #0,SCSIISR        ; no interrupt from selection
  998.     move.b    #$0c,SCSIICR        ; assert BSY and SEL
  999. ; set dest SCSI IDs
  1000.     clr.w    d0
  1001.     move.w    4(sp),d1        ; get the SCSI unit desired
  1002.     bset    d1,d0            ; set the appropriate bit
  1003.     move.b    d0,SCSIODR        ; (real code would set ours too)
  1004.  
  1005.     move.b    #$0d,SCSIICR        ; assert BUSY, SEL and data bus
  1006.     andi.b    #$FE,SCSIMR        ; clear arbitrate bit
  1007.     andi.b    #$F7,SCSIICR        ; clear BUSY
  1008.  
  1009. * there must be two "deskew delays" here, but that's only 100ns total...
  1010. * the following computations take at least that long before we read
  1011. * SCSICR again.
  1012.  
  1013.     bsr    setscstmout        ; use short time-out
  1014. sels3:    btst    #6,SCSICR        ; wait for bus to be busy
  1015.     bne.b    sels5
  1016.     cmp.l    (a0),d1
  1017.     bhi.b    sels3
  1018.  
  1019. sels4:    moveq    #-1,d0            ; time out
  1020.     bra.b    sels6
  1021.     
  1022. sels5:    clr.w    d0            ; selection successful
  1023. sels6:    move.b    #$0,SCSIICR        ; clear SEL and data bus assertion
  1024.     rts
  1025.  
  1026.  
  1027. ;+
  1028. ; w4stat - wait for status byte and message byte.
  1029. ;
  1030. ; Returns:
  1031. ;    d0.l = returned status or time-out error
  1032. ;-
  1033. w4stat:    bsr    setscstmout        ; set up time-out for REQ and ACK
  1034.     move.b    #3,SCSITCR        ; status in phase
  1035.     move.b    SCSIREI,d0        ; clear potential interrupt
  1036.  
  1037.     bsr    w4req            ; wait for status byte
  1038.     bmi.b    wstto            ; if timed-out, handle it
  1039.     moveq    #0,d0            ; clear d0
  1040.     move.b    SCSIDB,d0        ; get the status byte
  1041.     bsr    setscstmout        ; set up time-out for REQ and ACK
  1042.     move.l    d0,-(sp)        ; save the status byte
  1043.     bsr    doack            ; signal that status byte is here
  1044.     tst.w    d0            ; timed-out?
  1045.     beq.b    wst4            ; if not, wait for message byte
  1046.  
  1047. wst3:    addq.l    #4,sp            ; else clean up stack
  1048. wstto:    bsr    _resetscsi        ; timed-out, reset SCSI bus
  1049.     bra.b    wstend            ; and return
  1050.  
  1051. wst4:    bsr    setscstmout        ; set up time-out for REQ and ACK
  1052.     bsr    w4req            ; wait for message byte
  1053.     bmi.b    wst3            ; if timed-out, returns
  1054.  
  1055.     move.b    SCSIDB,d0        ; get and ignore message byte
  1056.     bsr    doack            ; signal that message byte is here
  1057.     tst.w    d0            ; timed-out?
  1058.     bmi.b    wst3            ; if so, return time-out
  1059.     move.l    (sp)+,d0        ; recall the status byte
  1060. wstend:    rts
  1061.  
  1062.  
  1063. ;+
  1064. ; w4req() - wait for REQ to come
  1065. ;
  1066. ; Passed:
  1067. ;    d1.l = expiration time
  1068. ;    a0.l = address of _hz_200
  1069. ;
  1070. ; Returns:
  1071. ;     0 - if successful
  1072. ;    -1 - times out
  1073. ;-
  1074. w4req:
  1075. wr0:    btst    #5,SCSICR        ; waiting for REQ to come
  1076.     bne.b    wr1            ; if REQ comes, done
  1077.     cmp.l    (a0),d1            ; time's up?
  1078.     bhi.b    wr0            ; if not, wait some more
  1079.     moveq    #-1,d0            ; else, returns timed out
  1080.     bra.b    wrend
  1081. wr1:    moveq    #0,d0            ; returns successful
  1082. wrend:    rts
  1083.  
  1084.  
  1085. ;+
  1086. ; doack() - assert ACK
  1087. ;
  1088. ; Passed:
  1089. ;    d1.l = expiration time
  1090. ;    a0.l = address of _hz_200
  1091. ;
  1092. ; Returns:
  1093. ;     0 - if successful
  1094. ;    -1 - times out
  1095. ;-
  1096. doack:    ori.b    #$11,SCSIICR        ; assert ACK (and data bus)
  1097. da0:    btst    #5,SCSICR        ; wait for REQ to go away
  1098.     beq.b    da1            ; if REQ goes away, done
  1099.     cmp.l    (a0),d1            ; time's up?
  1100.     bhi.b    da0            ; if not, wait some more
  1101.     moveq    #-1,d0            ; else returns timed out
  1102.     bra.b    daend
  1103. da1:    moveq    #0,d0            ; returns successful
  1104. daend:    andi.b    #$ef,SCSIICR        ; clear ACK
  1105.     rts
  1106.  
  1107.  
  1108. ;+
  1109. ; hshake() - hand shake a byte over to the controller
  1110. ;
  1111. ; Passed:
  1112. ;    d0.b = byte to be handed over
  1113. ;    d1.l = expiration time
  1114. ;    a0.l = address of _hz_200
  1115. ;
  1116. ; Returns:
  1117. ;    Whatever w4req() or doack() returns, which is:
  1118. ;         0 - if successful
  1119. ;        -1 - times out
  1120. ;-
  1121. hshake:    move.w    d0,-(sp)        ; preserve d0.w
  1122.     bsr    w4req            ; wait for REQ to come
  1123.     bmi.b    hsend            ; if timed out, returns
  1124.     move.b    1(sp),SCSIDB        ; write a byte out to data bus
  1125.     bsr    doack            ; assert ACK
  1126. hsend:    addq.l    #2,sp            ; clean up stack
  1127.     rts
  1128.  
  1129.  
  1130. *+
  1131. * VOID resetscsi();
  1132. *-
  1133.  
  1134. _resetscsi:
  1135.     move.b    #$80,SCSIICR    ; assert RST
  1136.     bsr    setscstmout    ; wait (at least) 250 ms
  1137. rst0:    cmp.l    (a0),d1
  1138.     bhi.b    rst0
  1139.     move.b    #$00,SCSIICR
  1140.     bsr    setscltmout    ; wait (at least) 1000 ms
  1141. rst1:    cmp.l    (a0),d1
  1142.     bhi.b    rst1
  1143.     move.b    SCSIREI,d1    ; clear potential interrupt
  1144.     rts
  1145.  
  1146.  
  1147. ;+
  1148. ; setscstmout - set up a time-out count for the SCSI for SCSTMOUT ticks
  1149. ;
  1150. ; Returns:
  1151. ;    a0.l = address of _hz_200 clock
  1152. ;    d1.l = expiration time
  1153. ;-
  1154. setscstmout:
  1155.     movea.l    #_hz_200,a0    ; a0 -> 200 hz clock
  1156.     move.l    #SCSTMOUT,d1    ; d0 = SCSTMOUT _hz_200 clicks
  1157.     add.l    (a0),d1        ; d0 = curr time + # clicks to wait
  1158.     rts
  1159.  
  1160.  
  1161. ;+
  1162. ; setscltmout - set up a time-out count for the SCSI for SCLTMOUT long
  1163. ;
  1164. ; Returns:
  1165. ;    a0.l = address of _hz_200 clock
  1166. ;    d1.l = expiration time
  1167. ;-
  1168. setscltmout:
  1169.     movea.l    #_hz_200,a0    ; a0 -> 200 hz clock
  1170.     move.l    #SCLTMOUT,d1    ; d0 = SCLTMOUT _hz_200 clicks
  1171.     add.l    (a0),d1        ; d0 = curr time + # clicks to wait
  1172.     rts
  1173.  
  1174. .endif
  1175.  
  1176.  
  1177.  
  1178. .if    SPSCSI
  1179.  
  1180. ;+++++++++++++++++++++++++++++++;
  1181. ;                ;
  1182. ;    SPARROW specific    ;
  1183. ;                ;
  1184. ;+++++++++++++++++++++++++++++++;
  1185.  
  1186. .globl    _resetspscsi
  1187.  
  1188. bSPSCSI        equ    $88    ; base of SCSI bus
  1189.  
  1190. ; SCSI Interface (NCR 5380) for READ operations
  1191. SPSCSIDB    equ    bSPSCSI+0    ; SCSI data bus
  1192. SPSCSIICR    equ    bSPSCSI+1    ; initiator command register
  1193. SPSCSIMR    equ    bSPSCSI+2    ; mode register
  1194. SPSCSITCR    equ    bSPSCSI+3    ; target command register
  1195. SPSCSICR    equ    bSPSCSI+4    ; current SCSI control register
  1196. SPSCSIDSR    equ    bSPSCSI+5    ; DMA status register
  1197. SPSCSIIDR    equ    bSPSCSI+6    ; input data register
  1198. SPSCSIREI    equ    bSPSCSI+7    ; reset error / interrupt
  1199.  
  1200.  
  1201. ; SCSI Interface (NCR 5380) for WRITE operations
  1202. SPSCSIODR    equ    bSPSCSI+0    ; output data register
  1203. ;SPSCSIICR    equ    bSPSCSI+1    ; initiator command register
  1204. ;SPSCSIMR    equ    bSPSCSI+2    ; mode register
  1205. ;SPSCSITCR    equ    bSPSCSI+3    ; target command register
  1206. SPSCSIISR    equ    bSPSCSI+4    ; ID select register
  1207. SPSCSIDS    equ    bSPSCSI+5    ; start DMA send
  1208. SPSCSIDTR    equ    bSPSCSI+6    ; start DMA target receive
  1209. SPSCSIDIR    equ    bSPSCSI+7    ; start DMA initiator receive
  1210.  
  1211.  
  1212. ; Macros to talk to the NCR5380 through the ACSI DMA chip
  1213.  
  1214. .macro    RSCSI    srcreg,dst    ; read from specified register
  1215.     move.w    srcreg,WDL
  1216.     move.w    WDC,dst
  1217. .endm
  1218.  
  1219. .macro    WSCSI    val,dstreg    ; write to specified register
  1220.     move.w    dstreg,WDL
  1221.     move.w    val,WDC
  1222. .endm
  1223.  
  1224. ;+
  1225. ; Tunable (delay) values (in number of _hz_200 ticks) for SCSI
  1226. ;-
  1227. SCLTMOUT    equ    301        ; long time-out (at least 1.5 s)
  1228. SCSTMOUT    equ    51        ; short time-out (at least 250 ms)
  1229.  
  1230. ;+
  1231. ; rcvspscsi() - send a SCSI command which receives data back.
  1232. ;
  1233. ; Passed:
  1234. ;    d0.w = physical unit number
  1235. ;    d1.l = transfer length (in bytes)
  1236. ;    d2.w = command length (NCMD or LCMD)
  1237. ;    a0.l = buffer address
  1238. ;-
  1239.     .globl    _rcvspscsi
  1240. _rcvspscsi:
  1241.     st    flock            ; lock FIFO
  1242.     andi.w    #7,d0            ; mask off the flags to get unit num
  1243.     movem.l    d1-d2/a0,-(sp)        ; save buffer address and cmd length
  1244.     bsr    sblkspscsi        ; send command block
  1245.     movem.l    (sp)+,d1-d2/a0        ; restore buffer address and cmd len
  1246.     tst.w    d0            ; successful?
  1247.     bmi    rspend            ; if not successful, return
  1248.  
  1249.     WSCSI    #0,#SPSCSIICR        ; deassert the data bus
  1250.     WSCSI    #1,#SPSCSITCR        ; set data in phase
  1251.     RSCSI    #SPSCSIREI,d0        ; clear potential interrupt
  1252.  
  1253. rpio:    movea.l    a0,a1            ; a1 -> buffer to read into
  1254. rnxtb:    bsr    setscstmout
  1255.     bsr    w4spreq            ; wait for REQ for data to come
  1256.     bmi    rspend            ; if timed out, returns
  1257.     RSCSI    #SPSCSIDSR,d0        ; still in data in phase?
  1258.     btst    #3,d0            
  1259.     beq    rstat            ; if not, go get status
  1260.     RSCSI    #bSPSCSI,d0        ; else read the next data byte
  1261.     move.b    d0,(a1)+    
  1262.     bsr    dospack
  1263.     bra    rnxtb            ; do next byte
  1264. rstat:    bsr    w4spstat        ; go get status byte
  1265. rspend:    RSCSI    #SPSCSIREI,d1        ; clear potential interrupt
  1266.     bra    _hdone            ; go clean up
  1267.  
  1268.  
  1269.  
  1270. ;+
  1271. ; wrtspscsi() - send a SCSI command which will write data to the target
  1272. ;
  1273. ; Passed:
  1274. ;    d0.w = physical unit number
  1275. ;    d1.l = transfer length (in bytes)
  1276. ;    d2.w = command length (NCMD or LCMD)
  1277. ;    a0.l = buffer address
  1278. ;
  1279. ; Comments: 
  1280. ; 12/04/89 ml
  1281. ;    Bus error occurs when doing a write to the disk that ends at top
  1282. ; of memory.  The DMA counter is decremented when the bytes are written 
  1283. ; from the ping pong buffers to the device, not when bytes are grapped 
  1284. ; from RAM to the ping pong buffers.  Well, AFTER the last 8 bytes are 
  1285. ; read into the ping pong buffers and BEFORE they are written to the 
  1286. ; device, the chip will attempt to read the NEXT 8 bytes into the ping 
  1287. ; pong buffers which results in a bus error because it will be reading 
  1288. ; pass top of memory.  To get around this HARDWARE BUG, the code will 
  1289. ; ALWAYS handshake the last 8 bytes over instead of DMAing them.
  1290. ;
  1291. ; 01/23/90 ml
  1292. ;    A. Pratt said he's willing to move the screen down and sacrifice
  1293. ; 16 bytes of memory.  So, code added on 12/04/89 is commented out.
  1294. ;-
  1295.     .globl    _wrtspscsi
  1296. _wrtspscsi:
  1297.     st    flock            ; lock FIFO
  1298.     andi.w    #7,d0            ; mask off the flags to get unit num
  1299.  
  1300.     movem.l    d1-d2/a0,-(sp)        ; save beginning buffer address
  1301.     bsr    sblkspscsi        ; send command block
  1302.     movem.l    (sp)+,d1-d2/a0        ; a0 = where DMA ends
  1303.     tst.w    d0            ; successful?
  1304.     bmi    wspend            ; if not, go clean up
  1305.  
  1306.     WSCSI    #0,#SPSCSITCR        ; set data out phase
  1307.     RSCSI    #SPSCSIREI,d0        ; clear potential interrupt
  1308.                     ; hand shake data over the bus
  1309. wpio:    movea.l    a0,a1            ; a1 -> buffer to write from
  1310. wnxtb:    bsr    setscstmout
  1311.     bsr    w4spreq            ; wait for REQ for data to come
  1312.     bmi    wspend            ; if timed out, returns
  1313.     RSCSI    #SPSCSIDSR,d0
  1314.     btst    #3,d0            ; still in data out phase?
  1315.     beq    wstat            ; if not, go get status
  1316.     moveq    #0,d0
  1317.     move.b    (a1)+,d0        ; write the next data byte
  1318.     WSCSI    d0,#bSPSCSI
  1319.     bsr    dospack
  1320.     bra    wnxtb            ; do next byte
  1321. wstat:    bsr    w4spstat        ; get status byte
  1322. wspend:    RSCSI    #SPSCSIREI,d1        ; clear potential interrupt
  1323.     bra    _hdone            ; go clean up
  1324.  
  1325.  
  1326.  
  1327. ;+
  1328. ; sblkspscsi() - set DMA pointer and count and send command block
  1329. ;
  1330. ; Passed:
  1331. ;    d0.w = physical unit number
  1332. ;    d1.l = transfer length (in bytes)
  1333. ;    d2.w = command length (NCMD or LCMD)
  1334. ;    a0.l = buffer address
  1335. ;
  1336. ; Returns:
  1337. ;    d0.l =  0 if successful
  1338. ;    d0.l = -1 if timeout
  1339. ;-
  1340. sblkspscsi:
  1341.     movem.l    d1-d2/a0,-(sp)        ; preserve d1, d2 and a0
  1342.     move.w    d0,-(sp)        ; physical unit #
  1343.     bsr    selspscsi        ; select the unit
  1344.     addq.l    #2,sp            ; clean up stack
  1345.     movem.l    (sp)+,d1-d2/a0        ; restore d1, d2 and a0
  1346.     tst.w    d0            ; selection successful?
  1347.     bmi    sbspend            ; if timed out, return
  1348.                     ; else proceed
  1349.     WSCSI    #2,#SPSCSITCR        ; assert C/D
  1350.     WSCSI    #1,#SPSCSIICR        ; assert data bus
  1351.  
  1352.     bsr    setscltmout        ; set up timeout for sending cmdblk
  1353.     lea    _cmdblk,a1        ; a1 -> command block
  1354.     subq.w    #1,d2            ; dbra likes one less
  1355. sbsp0:    move.b    (a1)+,d0        ; d0.b = byte to be sent
  1356.     bsr    sphshake        ; write that byte
  1357.     tst.w    d0
  1358.     bmi    sbspend            ; if timed-out, returns
  1359.     dbra    d2,sbsp0        ; until whole command block is sent
  1360.     moveq    #0,d0            ; all operations successful
  1361. sbspend: rts                ; heading home
  1362.  
  1363.  
  1364. ;+
  1365. ; BOOLEAN selspscsi(SCSIUnit) 
  1366. ; WORD SCSIUnit;
  1367. ;-
  1368. selspscsi:
  1369.     bsr    setscstmout        ; set up a short timeout
  1370. selsp0:    RSCSI    #SPSCSICR,d0
  1371.     btst    #6,d0            ; STILL busy from last time?
  1372.     beq    selsp1            ; if not, it's available
  1373.     cmp.l    (a0),d1            ; timeout?
  1374.     bhi    selsp0            ; not yet, wait some more
  1375.     bra    selsp3            ; else, return error
  1376.  
  1377. selsp1:    WSCSI    #0,#SPSCSITCR        ; data out phase
  1378.     WSCSI    #0,#SPSCSIISR        ; no interrupt from selection
  1379.     WSCSI    #$0c,#SPSCSIICR        ; assert BSY and SEL
  1380. ; set dest SCSI IDs
  1381.     clr.w    d0
  1382.     move.w    4(sp),d1        ; get the SCSI unit desired
  1383.     bset    d1,d0            ; set the appropriate bit
  1384.     WSCSI    d0,#SPSCSIODR        ; (real code would set ours too)
  1385.  
  1386. ;    WSCSI    #$0d,#SPSCSIICR        ; assert BUSY, SEL and data bus
  1387.     WSCSI    #$05,#SPSCSIICR        ; assert SEL and data bus
  1388.     RSCSI    #SPSCSIMR,d0        ; read Mode Register
  1389.     andi.b    #$FE,d0            ; clear arbitrate bit
  1390.     WSCSI    d0,#SPSCSIMR
  1391.     RSCSI    #SPSCSIICR,d0        ; read Initiator Command Register
  1392.     andi.b    #$F7,d0            ; clear BUSY
  1393.     WSCSI    d0,#SPSCSIICR
  1394.     nop                ; 2 deskew delays
  1395.     nop
  1396.  
  1397.     bsr    setscstmout        ; set up for timeout
  1398. selsp2:    RSCSI    #SPSCSICR,d0        ; wait for bus to be busy
  1399.     btst    #6,d0
  1400.     bne    selsp4
  1401.     cmp.l    (a0),d1
  1402.     bhi    selsp2
  1403.  
  1404. selsp3:    moveq    #-1,d0            ; time out
  1405.     bra    selsp5
  1406.     
  1407. selsp4:    clr.w    d0            ; selection successful
  1408. selsp5:    WSCSI    #0,#SPSCSIICR        ; clear SEL and data bus assertion
  1409.     rts
  1410.  
  1411.  
  1412. *+
  1413. * VOID resetspscsi();
  1414. *-
  1415.     .globl    _resetspscsi
  1416. _resetspscsi:
  1417.     WSCSI    #$80,#SPSCSIICR    ; assert RST
  1418.     bsr    setscstmout    ; wait (at least) 250 ms
  1419. rstsp0:    cmp.l    (a0),d1
  1420.     bhi    rstsp0
  1421.     WSCSI    #0,#SPSCSIICR
  1422.     bsr    setscltmout    ; wait (at least) 1000 ms
  1423. rstsp1:    cmp.l    (a0),d1
  1424.     bhi    rstsp1
  1425.     RSCSI    #SPSCSIREI,d0        ; clear potential interrupt
  1426.     rts
  1427.  
  1428.  
  1429. ;+
  1430. ; w4spstat - wait for status byte and message byte.
  1431. ;
  1432. ; Returns:
  1433. ;    d0.l = returned status or timeout error
  1434. ;-
  1435. w4spstat:
  1436.     bsr    setscstmout        ; set up time-out for REQ and ACK
  1437.     WSCSI    #3,#SPSCSITCR        ; status in phase
  1438.     RSCSI    #SPSCSIREI,d0        ; clear potential interrupt
  1439.  
  1440.     bsr    w4spreq            ; wait for status byte
  1441.     bmi    w4spend            ; if timed-out, returns
  1442. gspstat:
  1443.     RSCSI    #SPSCSIDB,d0        ; get the status byte
  1444.     andi.w    #$ff,d0
  1445.     move.l    d0,-(sp)        ; save the status byte
  1446.     bsr    setscstmout        ; set up time-out for REQ and ACK
  1447.     bsr    dospack            ; signal that status byte is here
  1448.     tst.w    d0            ; timed-out?
  1449.     beq    gsp1            ; if not, wait for message byte
  1450.  
  1451. gsp0:    addq.l    #4,sp            ; else clean up stack
  1452.     bra    w4spend            ; and return
  1453.  
  1454. gsp1:    bsr    setscstmout        ; set up timeout for REQ and ACK
  1455.     bsr    w4spreq            ; wait for message byte
  1456.     bmi    gsp0            ; if timed-out, returns
  1457.  
  1458.     RSCSI    #SPSCSIDB,d0        ; get and ignore message byte
  1459.     bsr    dospack            ; signal that message byte is here
  1460.     tst.w    d0            ; timed-out?
  1461.     bmi    gsp0            ; if so, return timeout
  1462.     move.l    (sp)+,d0        ; recall the status byte
  1463. w4spend:
  1464.     rts                ; return
  1465.  
  1466.  
  1467. ;+
  1468. ; w4spreq() - wait for REQ to come during hand shake of non-data bytes
  1469. ;
  1470. ; Passed:
  1471. ;    d1.l = expiration time
  1472. ;    a0.l = address of _hz_200
  1473. ;
  1474. ; Returns:
  1475. ;     0 - if successful
  1476. ;    -1 - times out
  1477. ;-
  1478. w4spreq:
  1479. w4sp0:    RSCSI    #SPSCSICR,d0        ; read Control Register
  1480.     btst    #5,d0            ; waiting for REQ to come
  1481.     bne    w4sp1            ; if REQ comes, done
  1482.     cmp.l    (a0),d1            ; time's up?
  1483.     bhi    w4sp0            ; if not, wait some more
  1484.     moveq    #-1,d0            ; else, returns timed out
  1485.     bra    w4sprend
  1486. w4sp1:    moveq    #0,d0            ; returns successful
  1487. w4sprend:
  1488.     rts
  1489.  
  1490.  
  1491. ;+
  1492. ; dospack() - assert ACK
  1493. ;
  1494. ; Passed:
  1495. ;    d1.l = expiration time
  1496. ;    a0.l = address of _hz_200
  1497. ;
  1498. ; Returns:
  1499. ;     0 - if successful
  1500. ;    -1 - times out
  1501. ;-
  1502. dospack:    
  1503.     RSCSI    #SPSCSIICR,d0        ; read Initiator Command Register
  1504.     ori.b    #$11,d0            ; assert ACK (and data bus)
  1505.     WSCSI    d0,#SPSCSIICR
  1506.     andi.b    #$ef,d0            ; clear ACK
  1507.     WSCSI    d0,#SPSCSIICR
  1508.     moveq    #0,d0
  1509.     rts
  1510.  
  1511.  
  1512. ;+
  1513. ; sphshake() - hand shake a byte over to the controller
  1514. ;
  1515. ; Passed:
  1516. ;    d0.b = byte to be handed over
  1517. ;    d1.l = expiration time
  1518. ;    a0.l = address of _hz_200
  1519. ;
  1520. ; Returns:
  1521. ;    Whatever w4spreq() or dospack() returns, which is:
  1522. ;         0 - if successful
  1523. ;        -1 - times out
  1524. ;-
  1525. sphshake:
  1526.     move.w    d0,-(sp)        ; preserve d0.w
  1527.     bsr    w4spreq            ; wait for REQ to come
  1528.     bmi    hspend            ; if timed out, returns
  1529.     move.w    0(sp),d0
  1530.     WSCSI    d0,#SPSCSIDB        ; write a byte out to data bus
  1531.     bsr    dospack            ; assert ACK
  1532. hspend:    addq.l    #2,sp            ; clean up stack
  1533.     rts
  1534.  
  1535.  
  1536. ;+
  1537. ; setscstmout - set up a time-out count for the SCSI for SCSTMOUT ticks
  1538. ;
  1539. ; Returns:
  1540. ;    a0.l = address of _hz_200 clock
  1541. ;    d1.l = expiration time
  1542. ;-
  1543. setscstmout:
  1544.     movea.l    #_hz_200,a0    ; a0 -> 200 hz clock
  1545.     move.l    #SCSTMOUT,d1    ; d0 = SCSTMOUT _hz_200 clicks
  1546.     add.l    (a0),d1        ; d0 = curr time + # clicks to wait
  1547.     rts
  1548.  
  1549.  
  1550. ;+
  1551. ; setscltmout - set up a time-out count for the SCSI for SCLTMOUT long
  1552. ;
  1553. ; Returns:
  1554. ;    a0.l = address of _hz_200 clock
  1555. ;    d1.l = expiration time
  1556. ;-
  1557. setscltmout:
  1558.     movea.l    #_hz_200,a0    ; a0 -> 200 hz clock
  1559.     move.l    #SCLTMOUT,d1    ; d0 = SCLTMOUT _hz_200 clicks
  1560.     add.l    (a0),d1        ; d0 = curr time + # clicks to wait
  1561.     rts
  1562.  
  1563. .endif
  1564.  
  1565.  
  1566.  
  1567. .if IDE_AT
  1568.  
  1569. ;+++++++++++++++++++++++++++++++;
  1570. ;                ;
  1571. ;    IDE-AT specific        ;
  1572. ;                ;
  1573. ;+++++++++++++++++++++++++++++++;
  1574.  
  1575. ; IDE disk interface I/O locations for Read functions
  1576.  
  1577. bIDE    equ    $FFF00000+REGBASE    ; base address
  1578.  
  1579. IDEDR    equ    bIDE-REGBASE+($00*REGLSTEP); Data Register (16-bit reg)
  1580. IDEER    equ    bIDE+($01*REGLSTEP)    ; Error Register
  1581. IDESC    equ    bIDE+($02*REGLSTEP)    ; Sector Count
  1582. IDESN    equ    bIDE+($03*REGLSTEP)    ; Sector Number
  1583. IDECL    equ    bIDE+($04*REGLSTEP)    ; Cylinder Low
  1584. IDECH    equ    bIDE+($05*REGLSTEP)    ; Cylinder High (2 bits)
  1585. IDESDH    equ    bIDE+($06*REGLSTEP)    ; SDH register
  1586. IDESR    equ    bIDE+($07*REGLSTEP)    ; Status Register
  1587. IDEASR    equ    bIDE+($0E*REGLSTEP)    ; Alternate Status Register
  1588. IDEDAR    equ    bIDE+($0F*REGLSTEP)    ; Drive Address Register
  1589.  
  1590.  
  1591.  
  1592. ; IDE disk interface I/O locations for Write functions
  1593.  
  1594. ;IDEDR    equ    bIDE-REGBASE+($00*REGLSTEP); Data Register (16-bit reg)
  1595. IDEWPR    equ    bIDE+($01*REGLSTEP)    ; Write Precomp Register (not used)
  1596. ;IDESC    equ    bIDE+($02*REGLSTEP)    ; Sector Count
  1597. ;IDESN    equ    bIDE+($03*REGLSTEP)    ; Sector Number
  1598. ;IDECL    equ    bIDE+($04*REGLSTEP)    ; Cylinder Low
  1599. ;IDECH    equ    bIDE+($05*REGLSTEP)    ; Cylinder High (2 bits)
  1600. ;IDESDH    equ    bIDE+($06*REGLSTEP)    ; SDH register
  1601. IDECR    equ    bIDE+($07*REGLSTEP)    ; Command Register
  1602. IDEDOR    equ    bIDE+($0E*REGLSTEP)    ; Digital Output Register
  1603.  
  1604.  
  1605. ; Byte indices into buffer return by the Identify command
  1606.  
  1607. NCYL    equ    2        ; offset to # of fixed cylinders
  1608. NHEAD    equ    6        ; offset to number of heads
  1609. NSPT    equ    12        ; offset to number of sectors/track
  1610. MDLNUM    equ    54        ; offset to model number of drive
  1611. CONMDL    equ    MDLNUM+26    ; offset to Conner's model number
  1612.  
  1613.  
  1614. ; Default drive parameters of Conner Peripherals - CP2024
  1615. CP20NCYL    equ    615    ; # of cylinders
  1616. CP20NHEAD    equ    4    ; # of heads
  1617. CP20NSPT    equ    17    ; # of sectors/track
  1618.  
  1619.  
  1620. ;+
  1621. ; Wait for status to come back
  1622. ;-
  1623. w4int:    move.l    #D_WORST,d0    ; d0 = time-out limit
  1624.     add.l    _hz_200,d0    ; d0 = expiration time
  1625. wi0:    btst.b    #5,GPIP        ; interrupt?
  1626.     beq.b    wi1        ; if so, out of the loop
  1627.     cmp.l    _hz_200,d0    ; time-out?
  1628.     bhi.b    wi0        ; if not, wait some more
  1629.     moveq    #-1,d0        ; else, return time-out
  1630.     bra.b    wi3
  1631. wi1:    moveq    #0,d0        ; clear d0
  1632.     move.b    IDESR,d0    ; d0.b = status returned
  1633.     btst    #0,d0        ; any error?
  1634.     bne.b    wi2        ; if yes, return error code
  1635.     btst    #3,d0        ; else DRQ?
  1636.     bne.b    wi3        ; if so, just return
  1637.     moveq    #0,d0        ; else return OK
  1638.     bra.b    wi3
  1639. wi2:    move.b    IDEER,d0    ; else d0.b = error bits
  1640. wi3:    rts            ; return status or error code
  1641.  
  1642.  
  1643.  
  1644. ;+
  1645. ; ideread() - reads from 1 to 256 sectors as specified in the Task File,
  1646. ;        beginning at the specified sector.
  1647. ;       - sector count equal to 0 requests 256 sectors.
  1648. ;
  1649. ; ideread(nhd, nspt, sectnum, count, buf, pdev)
  1650. ; WORD    nhd;        4(sp).w        ; # of data heads on pdev
  1651. ; WORD    nspt;        6(sp).w        ; # of physical sectors per track
  1652. ; LONG    sectnum;    8(sp).l        ; logical block address
  1653. ; WORD    count;        $c(sp).w    ; # of sectors to read
  1654. ; BYTE    *buf;        $e(sp).l    ; $f(sp)=high $10(sp)=mid $11(sp)=low
  1655. ; WORD    pdev;        $12(sp).w    ; physical device number
  1656. ;-
  1657.     .globl    _ideread
  1658. _ideread:
  1659.     bsr    set_dhcs    ; set physical address
  1660.     move.l    $e(sp),a0    ; a0 -> buffer to read into
  1661.     move.b    $d(sp),IDESC    ; set sector count
  1662.  
  1663.     move.w    $c(sp),d1    ; d1.w = # of sectors to read
  1664.     subq    #1,d1        ; dbra likes one less
  1665.  
  1666.     move.b    #0,IDEDOR    ; enable interrupt
  1667.     move.b    #IDEREAD,IDECR    ; set command code
  1668. ider0:    bsr    w4int        ; wait for interrupt
  1669.     tst.w    d0        ; successful?
  1670.     bmi.b    ider1        ; if timed-out, return
  1671.  
  1672.     btst    #3,d0        ; DRQ?
  1673.     beq.b    ider1        ; if not, return
  1674.  
  1675.     bsr    readbuf        ; fill sector buffer
  1676.     dbra    d1,ider0    ; more to read?
  1677.     moveq    #0,d0        ; everything's fine
  1678. ider1:    rts
  1679.  
  1680.  
  1681. ;+
  1682. ; idewrite() - writes from 1 to 256 sectors as specified in the Task File,
  1683. ;        beginning at the specified sector.
  1684. ;        - sector count equal to 0 requests 256 sectors.
  1685. ;
  1686. ; idewrite(nhd, nspt, sectnum, count, buf, pdev)
  1687. ; WORD    nhd;        4(sp).w        ; # of data heads on pdev
  1688. ; WORD    nspt;        6(sp).w        ; # of physical sectors per track
  1689. ; LONG    sectnum;    8(sp).l        ; logical block address
  1690. ; WORD    count;        $c(sp).w    ; # sectors to read
  1691. ; BYTE    *buf;        $e(sp).l    ; $f(sp)=high $10(sp)=mid $11(sp)=low
  1692. ; WORD    pdev;        $12(sp).w    ; physical device number
  1693. ;-
  1694.     .globl    _idewrite
  1695. _idewrite:    
  1696.     bsr    set_dhcs    ; set physical address
  1697.     move.l    $e(sp),a0    ; a0 -> buffer to write from
  1698.     move.b    $d(sp),IDESC    ; set sector count
  1699.  
  1700.     move.w    $c(sp),d1    ; d1.w = # of sectors to read
  1701.     subq    #1,d1        ; dbra likes one less
  1702.  
  1703.     move.b    #0,IDEDOR    ; enable interrupt
  1704.     move.b    #IDEWRITE,IDECR    ; set command code
  1705. idew0:    btst.b    #3,IDEASR    ; DRQ?
  1706.     beq.b    idew0        ; if not, wait longer
  1707. idew1:    bsr    wrtbuf        ; fill sector buffer
  1708.     bsr    w4int        ; wait for interrupt
  1709.     tst.w    d0        ; successful?
  1710.     bmi.b    idew2        ; if timed-out, return
  1711.     btst    #3,d0        ; DRQ?
  1712.     beq.b    idew2        ; if not, return
  1713.     dbra    d1,idew1    ; else go transfer data
  1714.     moveq    #0,d0        ; everything's fine
  1715. idew2:    rts
  1716.  
  1717.  
  1718. ;+
  1719. ; set_dhcs() - convert a logical block address into a physical address.
  1720. ;         - set drive #, head #, cylinder # and sector # in task file.
  1721. ;
  1722. ; Passed:
  1723. ;    8(sp).w = nhd = # of data heads
  1724. ;    $a(sp).w = nspt = # of physical sectors per track
  1725. ;    $c(sp).l = logical block address
  1726. ;    $16(sp).w = physical unit #
  1727. ;-
  1728. set_dhcs:
  1729.     move.l    $c(sp),d1    ; d1.l = logical block address
  1730.     move.w    8(sp),d2    ; d2.w = # of data heads
  1731.     move.w    $a(sp),d0    ; d0.w = # of physical sectors per track
  1732.     mulu    d0,d2        ; d2.l = # of sectors per cylinder
  1733.                 ;      = # heads * # of sectors per track
  1734.     divu.w    d2,d1        ; d1.w = cylinder #
  1735.                 ;      = log block addr / #spc
  1736.     move.b    d1,IDECL    ; set cylinder low
  1737.     lsr.l    #8,d1        ; d1.b = cylinder high
  1738.     move.b    d1,IDECH    ; set cylinder high
  1739.     lsr.l    #8,d1        ; d1.l = sector # within the cyl
  1740.     divu.w    d0,d1        ; d1.w = head #
  1741.                 ;      = sector # within cyl / #spt
  1742.     move.w    $16(sp),d0    ; d0.w = physical unit #
  1743.     andi.b    #7,d0        ; mask off flags from physical unit #
  1744.     lsl.b    #4,d0        ; shift unit # to place
  1745.     or.b    d0,d1        ; or in drive #
  1746.     move.b    d1,IDESDH    ; set drive and head #
  1747.     swap    d1        ; d1.w = sector # (base 0)
  1748.     addq.w    #1,d1        ;      = sector # + 1 (base 1)
  1749.     move.b    d1,IDESN    ; set sector #
  1750.     rts
  1751.  
  1752. ;+
  1753. ; identify() - allows the Host to receive parameter information from
  1754. ;           the drive.
  1755. ;
  1756. ; identify(pdev, buf)
  1757. ; WORD    pdev;    4(sp).w        ; physical unit #
  1758. ; BYTE    *buf;    6(sp).l        ; buffer to put data
  1759. ;-
  1760.     .globl    _identify
  1761. _identify:
  1762.     move.w    4(sp),d0    ; d0 = physical unit #
  1763.     andi.b    #7,d0        ; mask off flags (if any)
  1764.     lsl.b    #4,d0        ; shift unit # to place
  1765.     move.b    d0,IDESDH    ; set drive #
  1766.     move.l    6(sp),a0    ; a0 -> buffer
  1767.  
  1768.     move.b    #0,IDEDOR    ; enable interrupt
  1769.     move.b    #IDENTIFY,IDECR    ; set command code
  1770.     bsr    w4int        ; wait for interrupt
  1771.     tst.w    d0        ; successful?
  1772.     bmi.b    id0        ; if timed-out, return
  1773.     btst    #3,d0        ; DRQ?
  1774.     beq.b    id0        ; if not, return with error
  1775.  
  1776.     bsr    readbuf        ; read data
  1777.     moveq    #0,d0        ; everything's fine
  1778.  
  1779. id0:    rts 
  1780.  
  1781.  
  1782. ;+
  1783. ; readbuf() - reads 512 bytes (128 longs) of data into sector buffer.
  1784. ;
  1785. ; Passed:
  1786. ;    a0.l = buffer to store data read from sector buffer
  1787. ;-
  1788. readbuf:
  1789.     moveq    #31,d0        ; d0 = (# of words of data to read / 8) - 1
  1790.     lea    IDEDR,a1    ; a1 -> data bus
  1791. rb0:    move.w    (a1),(a0)+    ; read data from bus
  1792.     move.w    (a1),(a0)+    ; read data from bus
  1793.     move.w    (a1),(a0)+    ; read data from bus
  1794.     move.w    (a1),(a0)+    ; read data from bus
  1795.     move.w    (a1),(a0)+    ; read data from bus
  1796.     move.w    (a1),(a0)+    ; read data from bus
  1797.     move.w    (a1),(a0)+    ; read data from bus
  1798.     move.w    (a1),(a0)+    ; read data from bus
  1799.     dbra    d0,rb0        ; repeat until all done
  1800.     rts
  1801.  
  1802.  
  1803. ;+
  1804. ; wrtbuf() - writes 512 bytes (128 longs) of data to sector buffer.
  1805. ;
  1806. ; Passed:
  1807. ;    a0.l = buffer with data to write to sector buffer
  1808. ;-
  1809. wrtbuf:
  1810.     moveq    #31,d0        ; d0 = (# of words of data to read / 8) - 1
  1811.     lea    IDEDR,a1    ; a1 -> data bus
  1812. wb0:    move.w    (a0)+,(a1)    ; write data to bus
  1813.     move.w    (a0)+,(a1)    ; write data to bus
  1814.     move.w    (a0)+,(a1)    ; write data to bus
  1815.     move.w    (a0)+,(a1)    ; write data to bus
  1816.     move.w    (a0)+,(a1)    ; write data to bus
  1817.     move.w    (a0)+,(a1)    ; write data to bus
  1818.     move.w    (a0)+,(a1)    ; write data to bus
  1819.     move.w    (a0)+,(a1)    ; write data to bus
  1820.     dbra    d0,wb0        ; repeat until all done
  1821.     rts
  1822.  
  1823.  
  1824. ;+
  1825. ; _iderdy() - test if the IDE drive is ready
  1826. ;
  1827. ; Passed:
  1828. ;    d0.b = IDE drive unit #
  1829. ;
  1830. ; Returns: 0 - if drive is NOT ready
  1831. ;       1 - if drive is ready
  1832. ;-
  1833.     .globl    _iderdy
  1834. _iderdy:
  1835.     andi.b    #7,d0        ; mask off flags (if any)
  1836.     lsl.b    #4,d0        ; shift unit # to place
  1837.     move.b    d0,IDESDH    ; set drive #
  1838.     move.b    #$50,d1        ; ready status
  1839.     move.l    #IDERDY,d0    ; set up timer
  1840.     add.l    _hz_200,d0
  1841. ir0:    cmp.b    IDEASR,d1    ; is drive ready and not busy?
  1842.     beq.b    ir1        ; if so, return with drive ready
  1843.     cmp.l    _hz_200,d0    ; time-out yet?
  1844.     bcc.b    ir0        ; if not, wait longer
  1845.     moveq    #0,d0        ; else return drive NOT ready
  1846.     rts
  1847. ir1:    moveq    #1,d0        ; else, drive is ready
  1848.     rts
  1849.  
  1850. ;+
  1851. ; gcparm() - get current drive parameters
  1852. ;
  1853. ; gcparm(buf)
  1854. ; char    *buf;    $4(sp).l    /* -> data returned by identify() */
  1855. ;
  1856. ; Returns:
  1857. ;    d0.w = # of default cylinders
  1858. ;    d1.w = # of default heads
  1859. ;    d2.w = # of default sectors per track
  1860. ;-
  1861.     .globl    _gcparm
  1862. _gcparm:
  1863.     move.l    4(sp),a0    ; a0 -> data buffer
  1864.     add.l    #CONMDL,a0    ; a0 -> where Conner model number is
  1865.     move.l    a0,-(sp)
  1866.     pea    cp2024
  1867.     move.w    #6,-(sp)
  1868.     bsr    strcmp        ; compare model# with "CP2024"
  1869.     adda    #10,sp        ; clean up stack
  1870.     tst.w    d0        ; is unit the CP2024 (Kato 20Mb)?
  1871.     bne.b    gcp0        ; if not, handle the normal way
  1872.                 ; else return default values of CP2024
  1873.     move.w    #CP20NCYL,d0    ; d0.w = # of cylinders
  1874.     move.w    #CP20NHEAD,d1    ; d1.w = # of heads
  1875.     move.w    #CP20NSPT,d2    ; d2.w = # of spt
  1876.     bra.b    gcpend
  1877.  
  1878. gcp0:    move.l    4(sp),a0
  1879.     move.w    NCYL(a0),d0    ; d0.w = # of cylinders
  1880.     move.w    NHEAD(a0),d1    ; d1.w = # of heads
  1881.     move.w    NSPT(a0),d2    ; d2.w = # of sectors per track
  1882.  
  1883. gcpend:    rts
  1884.  
  1885.  
  1886.  
  1887. conner:    dc.b    "Conner",0
  1888. .even
  1889. cp2024:    dc.b    "CP2024",0
  1890. .even
  1891.  
  1892.  
  1893. ;+
  1894. ; strcmp() - compare two strings
  1895. ;
  1896. ; Passed:
  1897. ;    4(sp).w  = n (# of bytes to compare)
  1898. ;    6(sp).l  = address of first string
  1899. ;    10(sp).l = address of second string
  1900. ;
  1901. ; Returns:
  1902. ;    d0.w = 0    if first n bytes of the 2 strings are the same
  1903. ;         = non-0    otherwise
  1904. ;-
  1905. strcmp:    movem.l    d1/a0-a1,-(sp)    ; save registers d1, a0 and a1
  1906.     move.w    16(sp),d1    ; d1 = byte count
  1907.     subq.w    #1,d1        ; dbra likes one less
  1908.     move.l    18(sp),a0    ; a0 -> string 1
  1909.     move.l    22(sp),a1    ; a1 -> string 2
  1910.     moveq    #1,d0        ; assume strings are not the same
  1911. str0:    cmpm.b    (a0)+,(a1)+    ; characters the same?
  1912.     bne.b    str1        ; if not, return
  1913.     dbra    d1,str0        ; else compare next character
  1914.     moveq    #0,d0        ; the strings are the same
  1915. str1:    movem.l    (sp)+,d1/a0-a1    ; restore registers d1, a0 and a1
  1916.     rts
  1917.  
  1918.  
  1919. .endif
  1920.  
  1921.  
  1922.