home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX401 / IDE.S < prev    next >
Encoding:
Text File  |  2001-02-09  |  24.7 KB  |  905 lines
  1. ;+
  2. ; Edit History
  3. ;
  4. ; Sep-05-90    ml.    Created this for drives on the IDE bus.
  5. ;
  6. ; Mar-28-91    ml.    Do not use the IDE Sector Count Register 
  7. ;            to count down mulitiple sectors read or
  8. ;            write.  Some vendors (e.g. Conner and 
  9. ;            Seagate) seem to update this register 
  10. ;            too early, and every now and then, the
  11. ;            last sector of data would remain in the
  12. ;            internal sector buffer.  
  13. ;            
  14. ;            Code in ideread() and idewrite() are modified
  15. ;            not to use the IDE Sector Count Register.
  16. ;
  17. ; Aug-16-91    ml.    W4int() has been modified, in the case of
  18. ;            an error occurred, to return value in the 
  19. ;            Status register for driver code, and return 
  20. ;            value in the Error register for non-driver
  21. ;            code.
  22. ;
  23. ; Oct-10-91    ml.    Special-cased Conner drives for fmtunt() to
  24. ;            set drive to appropiate mode.  Added setmode().
  25. ;
  26. ; Oct-11-91    ml.    Special-cased Conner drives for read and write
  27. ;            to get current drive parameters.  Added gcparm().
  28. ;-
  29.  
  30. .include    "defs.h"
  31. .include    "sysvar.h"
  32. .include    "mfp.h"
  33. .include    "iderr.h"
  34. .include    "ide.h"
  35. .include    "blitter.h"
  36.  
  37. .extern    _useblit
  38.  
  39. ;+
  40. ; Wait for status to come back
  41. ;-
  42. w4int:    move.l    #D_WORST,d0    ; d0 = timeout limit
  43.     add.l    _hz_200,d0    ; d0 = expiration time
  44. .0:    btst.b    #5,GPIP        ; interrupt?
  45.     beq.s    .1        ; if so, out of the loop
  46.     cmp.l    _hz_200,d0    ; timeout?
  47.     bhi.s    .0        ; if not, wait some more
  48.     moveq    #$ff,d0        ; else, return timeout
  49.     bra.s    .3
  50. .1:    moveq    #0,d0        ; clear d0
  51.     move.b    IDESR,d0    ; d0.b = status returned
  52.     btst    #ERR,d0        ; any error?
  53.  
  54. .if    !DRIVER            ; for non-driver code
  55.     beq.s    .2        ; if no error, go on
  56.     move.b    IDEER,d0    ; else d0.b = error bits
  57.     bra.s    .3        ; return with error
  58.  
  59. .else                ; for driver code
  60.     bne.s    .3        ; if error, return
  61. .endif    ;!DRIVER
  62.  
  63. .2:    btst    #DRQ,d0        ; else DRQ?
  64.     bne.s    .3        ; if so, just return
  65.     moveq    #0,d0        ; else return OK
  66. .3:    rts            ; return status or error code
  67.  
  68.  
  69.  
  70. ;+
  71. ; ideread() - reads from 1 to 256 sectors as specified in the Task File,
  72. ;        beginning at the specified sector.
  73. ;        - sector count equal to 0 requests 256 sectors.
  74. ;
  75. ; ideread(nhd, nspt, sectnum, count, buf, pdev)
  76. ; WORD    nhd;        4(sp).w        ; # of data heads on pdev
  77. ; WORD    nspt;        6(sp).w        ; # of sectors per track
  78. ; LONG    sectnum;    8(sp).l        ; logical block address
  79. ; WORD    count;        $c(sp).w    ; # of sectors to read
  80. ; BYTE    *buf;        $e(sp).l    ; $f(sp)=high $10(sp)=mid $11(sp)=low
  81. ; WORD    pdev;        $12(sp).w    ; physical device number
  82. ;-
  83.     .globl    _ideread
  84. _ideread:
  85.     bsr    set_dhcs    ; set physical address
  86.     move.l    $e(sp),a0    ; a0 -> buffer to read into
  87.     move.b    $d(sp),IDESC    ; set sector count
  88.  
  89.     move.w    $c(sp),d1    ; d1.w = # of sectors to read
  90.     subq    #1,d1        ; dbra likes one less
  91.  
  92.     tst.b    _useblit    ; BLiTTER exists?
  93.     beq.s    .0        ; if not, don't use it
  94.     moveq    #0,d0        ; else it's a read
  95.     bsr    initblit    ; initialize the BLiTTER
  96.  
  97. .0:    move.b    #0,IDEDOR    ; enable interrupt
  98.     move.b    #READ,IDECR    ; set command code
  99. .1:    bsr    w4int        ; wait for interrupt
  100.     tst.w    d0        ; successful?
  101.     bmi.s    .2        ; if timed-out, return
  102.     btst    #DRQ,d0        ; DRQ?
  103.     beq.s    .2        ; if not, return
  104.                 ; else
  105.     bsr    readbuf        ; transfer data
  106.     dbra    d1,.1        ; go wait for next interrupt
  107.     moveq    #0,d0        ; everything is fine
  108. .2:    rts
  109.  
  110.  
  111. ;+
  112. ; idewrite() - writes from 1 to 256 sectors as specified in the Task File,
  113. ;        beginning at the specified sector.
  114. ;         - sector count equal to 0 requests 256 sectors.
  115. ;
  116. ; idewrite(nhd, nspt, sectnum, count, buf, pdev)
  117. ; WORD    nhd;        4(sp).w        ; # of data heads on pdev
  118. ; WORD    nspt;        6(sp).w        ; # of sectors per track
  119. ; LONG    sectnum;    8(sp).l        ; logical block address
  120. ; WORD    count;        $c(sp).w    ; # sectors to read
  121. ; BYTE    *buf;        $e(sp).l    ; $f(sp)=high $10(sp)=mid $11(sp)=low
  122. ; WORD    pdev;        $12(sp).w    ; physical device number
  123. ;-
  124.     .globl    _idewrite
  125. _idewrite:    
  126.     bsr    set_dhcs    ; set physical address
  127.     move.l    $e(sp),a0    ; a0 -> buffer to write from
  128.     move.b    $d(sp),IDESC    ; set sector count
  129.  
  130.     move.w    $c(sp),d1    ; d1.w = # of sectors to read
  131.     subq    #1,d1        ; dbra likes one less
  132.  
  133.     tst.b    _useblit    ; BLiTTER exists?
  134.     beq.s    .0        ; if not, don't use it
  135.     moveq    #1,d0        ; it's a write
  136.     bsr    initblit    ; initialize the BLiTTER
  137.  
  138. .0:    move.b    #0,IDEDOR    ; enable interrupt
  139.     move.b    #WRITE,IDECR    ; set command code
  140. .1:    btst.b    #DRQ,IDEASR    ; DRQ?
  141.     beq.s    .1        ; if not, wait longer
  142.  
  143. .2:    bsr    wrtbuf        ; transfer data
  144.     bsr    w4int        ; wait for interrupt
  145.     tst.w    d0        ; successful?
  146.     bmi.s    .3        ; if timed-out, return
  147.     btst    #DRQ,d0        ; DRQ?
  148.     beq.s    .3        ; if not, return
  149.     dbra    d1,.2        ; else go transfer data
  150.     moveq    #0,d0        ; everything is fine
  151. .3:    rts
  152.  
  153.  
  154. ;+
  155. ; set_dhcs() - convert a logical block address into a physical address.
  156. ;         - set drive #, head #, cylinder # and sector # in task file.
  157. ;
  158. ; Passed:
  159. ;    8(sp).w = nhd = # of data heads
  160. ;    $a(sp).w = nspt = # of sectors per track
  161. ;    $c(sp).l = logical block address
  162. ;    $16(sp).w = physical unit #
  163. ;-
  164. set_dhcs:
  165.     move.l    $c(sp),d1    ; d1.l = logical block address
  166.     move.w    8(sp),d2    ; d2.w = # of data heads
  167.     move.w    $a(sp),d0    ; d0.w = # of sectors per track
  168.     mulu    d0,d2        ; d2.l = # of sectors per cylinder
  169.                 ;      = # heads * # of sectors per track
  170.     divu.w    d2,d1        ; d1.w = cylinder #
  171.                 ;      = log block addr / #spc
  172.     move.b    d1,IDECL    ; set cylinder low
  173.     lsr.l    #8,d1        ; d1.b = cylinder high
  174.     move.b    d1,IDECH    ; set cylinder high
  175.     lsr.l    #8,d1        ; d1.l = sector # within the cyl
  176.     divu.w    d0,d1        ; d1.w = head #
  177.                 ;      = sector # within cyl / #spt
  178.     move.w    $16(sp),d0    ; d0.w = physical unit #
  179.     andi.b    #7,d0        ; mask off flags from physical unit #
  180.     lsl.b    #4,d0        ; shift unit # to place
  181.     or.b    d0,d1        ; or in drive #
  182.     move.b    d1,IDESDH    ; set drive and head #
  183.     swap    d1        ; d1.w = sector # (base 0)
  184.     addq.w    #1,d1        ;      = sector # + 1 (base 1)
  185.     move.b    d1,IDESN    ; set sector #
  186.     rts
  187.  
  188. ;+
  189. ; identify() - allows the Host to receive parameter information from
  190. ;           the drive.
  191. ;
  192. ; identify(pdev, buf)
  193. ; WORD    pdev;    4(sp).w        ; physical unit #
  194. ; BYTE    *buf;    6(sp).l        ; buffer to put data
  195. ;-
  196.     .globl    _identify
  197. _identify:
  198.     move.w    4(sp),d0    ; d0 = physical unit #
  199.     andi.b    #7,d0        ; mask off flags (if any)
  200.     lsl.b    #4,d0        ; shift unit # to place
  201.     move.b    d0,IDESDH    ; set drive #
  202.     move.l    6(sp),a0    ; a0 -> buffer
  203.  
  204.     tst.b    _useblit    ; BLiTTER exists?
  205.     beq.s    .0        ; if not, no need to init it
  206.     moveq    #0,d0        ; it's a read
  207.     bsr    initblit    ; initialize the BLiTTER
  208.  
  209. .0:    move.b    #0,IDEDOR    ; enable interrupt
  210.     move.b    #IDENTIFY,IDECR    ; set command code
  211.     bsr    w4int        ; wait for interrupt
  212.     tst.w    d0        ; successful?
  213.     bmi.s    .1        ; if timed-out, return
  214.     btst    #DRQ,d0        ; DRQ?
  215.     beq.s    .1        ; if not, return with error
  216.  
  217.     bsr    readbuf        ; read data
  218.     moveq    #0,d0        ; everything is fine
  219. .1:    rts 
  220.  
  221.  
  222. ;+
  223. ; awto() - set drive to Active mode with timeout counter (in 5s increments)
  224. ;
  225. ; awto(pdev, timeout)
  226. ; WORD    pdev;        4(sp).w        ; physical unit #
  227. ; WORD    timeout;    6(sp).w
  228. ;-
  229.     .globl    _awto
  230. _awto:    
  231.     move.w    4(sp),d0    ; d0 = physical unit #
  232.     andi.b    #7,d0        ; mask off flags (if any)
  233.     lsl.b    #4,d0        ; shift unit # to place
  234.     move.b    d0,IDESDH    ; set drive #
  235.     move.b    7(sp),IDESC    ; set timeout counter
  236.     move.b    #AWTO,IDECR    ; set command code
  237.     bra    w4int        ; go wait for interrupt
  238.  
  239.  
  240. ;+
  241. ; readbuf() - reads 512 bytes (128 longs) of data from the sector
  242. ;        buffer.
  243. ;
  244. ; Comments:
  245. ;    A tower of 8 move.l is used to try to speed up the transfer.
  246. ;
  247. ; Passed:
  248. ;    a0.l = buffer to store data read from sector buffer
  249. ;
  250. ;    if BLiTTER code
  251. ;    a1.l = base address of BLiTTER
  252. ;-
  253. readbuf:
  254.     tst.b    _useblit    ; BLiTTER exists?
  255.     beq.s    .0        ; if not, do programmed IO
  256.     move.w    #1,YCNT(a1)    ; one destination line
  257.     move.b    #$80,BUSY(a1)    ; start the BLiTTER
  258.     bsr    restart
  259.     addq.l    #2,DESTADDR(a1)    ; advance to next word of destination
  260.     rts
  261.                 ; Programmed IO
  262. .0:    moveq    #15,d0        ; d0 = (# of longs to read / 8) - 1
  263.     lea    IDEDR,a1    ; a1 -> data bus
  264. .1:    move.l    (a1),(a0)+    ; read data from bus
  265.     move.l    (a1),(a0)+    ; read data from bus
  266.     move.l    (a1),(a0)+    ; read data from bus
  267.     move.l    (a1),(a0)+    ; read data from bus
  268.     move.l    (a1),(a0)+    ; read data from bus
  269.     move.l    (a1),(a0)+    ; read data from bus
  270.     move.l    (a1),(a0)+    ; read data from bus
  271.     move.l    (a1),(a0)+    ; read data from bus
  272.     dbra    d0,.1        ; repeat until all done
  273.     rts
  274.  
  275.  
  276. ;+
  277. ; wrtbuf() - writes 512 bytes (128 longs) of data to sector buffer.
  278. ;
  279. ; Passed:
  280. ;    a0.l = buffer with data to write to sector buffer
  281. ;-
  282. wrtbuf:
  283.     tst.b    _useblit    ; BLiTTER exists?
  284.     beq.s    .0        ; if not, do programmed IO
  285.     move.w    #1,YCNT(a1)    ; one destination line
  286.     move.b    #$80,BUSY(a1)    ; start the BLiTTER
  287.     bsr    restart
  288.     addq.l    #2,SRCADDR(a1)    ; advance to next word of source
  289.     rts
  290.                 ; Programmed IO
  291. .0:    moveq    #15,d0        ; d0 = (# longs to write / 8) - 1
  292.     lea    IDEDR,a1    ; a1 -> data bus
  293. .1:    move.l    (a0)+,(a1)    ; write data to bus
  294.     move.l    (a0)+,(a1)    ; write data to bus
  295.     move.l    (a0)+,(a1)    ; write data to bus
  296.     move.l    (a0)+,(a1)    ; write data to bus
  297.     move.l    (a0)+,(a1)    ; write data to bus
  298.     move.l    (a0)+,(a1)    ; write data to bus
  299.     move.l    (a0)+,(a1)    ; write data to bus
  300.     move.l    (a0)+,(a1)    ; write data to bus
  301.     dbra    d0,.1        ;  repeat until all done
  302.     rts
  303.  
  304.  
  305. ;+
  306. ; initblit() - initialize the BLiTTER chip for 512 bytes I/O transfer
  307. ;
  308. ; Passed:
  309. ;    a0.l = destination address if read; source address if write
  310. ;    d0.w = flag to tell whether it's a read or a write
  311. ;-
  312. initblit:
  313.     lea    bBLiTTER,a1        ; a1 -> BLiTTER register map
  314.     tst.b    d0            ; read or write?
  315.     bne.s    ib0            ; (write)
  316.     move.l    #IDEDR,SRCADDR(a1)    ; source addr = IDE data register
  317.     move.l    a0,DESTADDR(a1)        ; destination addr = given buffer
  318.     move.w    #2,DESTXINC(a1)        ; words read
  319.     moveq    #0,d0
  320.     move.w    d0,SRCXINC(a1)        ; never increment source X
  321.     bra.s    ib1
  322.                     ; initialize BLiTTER to write to disk
  323. ib0:    move.l    a0,SRCADDR(a1)        ; source addr = write buffer
  324.     move.l    #IDEDR,DESTADDR(a1)    ; destination addr = IDE data reg
  325.     move.w    #2,SRCXINC(a1)        ; words write
  326.     moveq    #0,d0
  327.     move.w    d0,DESTXINC(a1)        ; never increment destination X
  328.  
  329. ib1:    move.w    d0,SRCYINC(a1)        ; never increment source Y
  330.     move.w    d0,DESTYINC(a1)        ; never increment destination Y
  331.     move.b    d0,SKEW(a1)        ; no skew
  332.     moveq    #$ff,d0
  333.     move.l    d0,ENDMASK1(a1)        ; change all bits at destination
  334.     move.w    d0,ENDMASK3(a1)        ; change all bits at destination
  335.     move.w    #$203,HOP(a1)        ; set HOP and OP to source
  336.     move.w    #256,XCNT(a1)        ; num of words to transfer
  337.     rts
  338.  
  339.  
  340. ;+
  341. ; restart() - restart the BLiTTER
  342. ;
  343. ; Passed:
  344. ;    a1.l = base address of BLiTTER
  345. ;-
  346. restart:
  347.     nop
  348.     tas    BUSY(a1)    ; restart BLiTTER and test if busy
  349.     bmi.s    restart        ; quit if not busy
  350.     rts
  351.  
  352.  
  353.  
  354.  
  355. ;+
  356. ; gparmfc() - get the current drive parameters for the C code
  357. ;
  358. ; gparmfc(addcyl, addhd, addspt, buf)
  359. ; char *addcyl;        $4(sp).l    /* the address of #cyl */
  360. ; char *addhd;        $8(sp).l    /* the address of #hd */
  361. ; char *addspt;        $c(sp).l     /* the address of #spt */
  362. ; char *buf;        $10(sp).l    /* the address of the date buffer */
  363. ; 
  364. ; returns: put the values of #cyl, #hd, #spt into the given addresses 
  365. ;-
  366.     .globl _gparmfc
  367. _gparmfc:
  368.     move.l $10(sp),-(sp); push the buffer address into the stack
  369.     bsr       _gcparm        ;
  370.     adda   #4,sp        ; clean up stack
  371.     move.l $4(sp),a0    ; a0 -> data buffer
  372.     move.w d0,(a0)        ; move the #cyl into its addr
  373.     move.l $8(sp),a0    ; a0 -> data buffer
  374.     move.w d1,(a0)        ; move the #hd into its addr
  375.     move.l $c(sp),a0    ; a0 -> data buffer
  376.     move.w d2,(a0)        ; move the #spt into its addr
  377.     rts
  378.  
  379.  
  380. ;+
  381. ; gcparm() - get current drive parameters
  382. ;
  383. ; gcparm(buf)
  384. ; char    *buf;    $4(sp).l    /* -> data returned by identify() */
  385. ;
  386. ; Returns:
  387. ;    d0.w = # of default cylinders
  388. ;    d1.w = # of default heads
  389. ;    d2.w = # of default sectors per track
  390. ;-
  391.     .globl    _gcparm
  392. _gcparm:
  393.     move.l    4(sp),a0    ; a0 -> data buffer
  394.     add.l    #CONMDL,a0    ; a0 -> where Conner model number is
  395.     move.l    a0,-(sp)
  396.     pea    cp2024
  397.     move.w    #6,-(sp)
  398.     bsr    strcmp        ; compare model# with "CP2024"
  399.     adda    #10,sp        ; clean up stack
  400.     tst.w    d0        ; is unit the CP2024 (Kato 20Mb)?
  401.     bne.s    gcp0        ; if not, handle the normal way
  402.                 ; else return default values of CP2024
  403.     move.w    #CP20NCYL,d0    ; d0.w = # of cylinders
  404.     move.w    #CP20NHEAD,d1    ; d1.w = # of heads
  405.     move.w    #CP20NSPT,d2    ; d2.w = # of spt
  406.     bra.s    gcpend
  407.  
  408. gcp0:    move.l    4(sp),a0
  409.     move.w    NCYL(a0),d0    ; d0.w = # of cylinders
  410.     move.w    NHEAD(a0),d1    ; d1.w = # of heads
  411.     move.w    NSPT(a0),d2    ; d2.w = # of sectors per track
  412.  
  413. gcpend:    rts
  414.  
  415.  
  416.  
  417. conner:    dc.b    "Conner",0
  418. .even
  419. cp2024:    dc.b    "CP2024",0
  420. .even
  421.  
  422.  
  423. ;+
  424. ; strcmp() - compare two strings
  425. ;
  426. ; Passed:
  427. ;    4(sp).w  = n (# of bytes to compare)
  428. ;    6(sp).l  = address of first string
  429. ;    10(sp).l = address of second string
  430. ;
  431. ; Returns:
  432. ;    d0.w = 0    if first n bytes of the 2 strings are the same
  433. ;         = non-0    otherwise
  434. ;-
  435. strcmp:    movem.l    d1/a0-a1,-(sp)    ; save registers d1, a0 and a1
  436.     move.w    16(sp),d1    ; d1 = byte count
  437.     subq.w    #1,d1        ; dbra likes one less
  438.     move.l    18(sp),a0    ; a0 -> string 1
  439.     move.l    22(sp),a1    ; a1 -> string 2
  440.     moveq    #1,d0        ; assume strings are not the same
  441. .0:    cmpm.b    (a0)+,(a1)+    ; characters the same?
  442.     bne.s    .1        ; if not, return
  443.     dbra    d1,.0        ; else compare next character
  444.     moveq    #0,d0        ; the strings are the same
  445. .1:    movem.l    (sp)+,d1/a0-a1    ; restore registers d1, a0 and a1
  446.     rts
  447.  
  448.  
  449. .if    !DRIVER
  450.  
  451. ;+
  452. ; recal() - moves the R/W heads from anywhere on the disk to cylinder 0.
  453. ;
  454. ; recal(pdev)
  455. ; WORD    pdev;    $4(sp).w
  456. ;-
  457.     .globl    _recal
  458. _recal:    move.w    4(sp),d0    ; d0 = physical unit #
  459.     andi.b    #7,d0        ; mask off flags (if any)
  460.     lsl.b    #4,d0        ; shift unit # to place
  461.     move.b    d0,IDESDH    ; write drive #
  462.     move.b    #0,IDEDOR    ; enable interrupt
  463.     move.b    #RECAL,IDECR    ; write command code
  464.     bra    w4int        ; go wait for interrupt
  465.  
  466.  
  467. ;+
  468. ; verify() - functions similarly to read() except that no data is
  469. ;         transferred to the host.
  470. ;-
  471.     .globl    _verify
  472. _verify:
  473.     move.w    $e(sp),d0    ; d0.w = physical unit #
  474.     move.l    4(sp),d1    ; d1.l = starting logical sector #
  475.     bsr    set_dhcs    ; set drive#, head#, cylinder# and sector#
  476.     move.l    $a(sp),a0    ; a0 -> buffer to write from
  477.     move.b    9(sp),IDESC    ; set sector count
  478.     move.b    #0,IDEDOR    ; enable interrupt
  479.     move.b    #VERIFY,IDECR    ; set command code
  480. .0:    bsr    w4int        ; wait for interrupt
  481.     bne.s    .1        ; if has error, return
  482.     tst.b    IDESC        ; more to verify?
  483.     bne.s    .0        ; if so, continue
  484.     moveq    #0,d0        ; everything's fine
  485. .1:    rts
  486.  
  487.  
  488. ;+
  489. ; fmtunt() - formats a unit
  490. ;       - always formats sectors as good ones.
  491. ;       - interleave 1:1.
  492. ;
  493. ; fmtunt(pdev)
  494. ; WORD    pdev;    4(sp).w
  495. ;-
  496.     .globl    _fmtunt
  497. _fmtunt:
  498.     move.l    d3,-(sp)    ; save d3
  499.     move.w    8(sp),-(sp)    ; set selected unit to the appropiate
  500.     bsr    setmode        ;  mode and get drive parameters in d1-d3
  501.     addq    #2,sp        ; clean up stack
  502.     tst.w    d0        ; setmode() ok?
  503.     bne    .5        ; if not, return
  504.                 ; else fill format data
  505.     bsr    clrsbuf        ; clear scratch buffer
  506.     moveq    #1,d0        ; d0 = sector # (starts with sector 1)
  507.     lea    sbuf,a1        ; a1 -> _identify() data buffer
  508. .0:    move.b    d0,(a1)+    ; set sector #
  509.     clr.b    (a1)+        ; format sector good
  510.     addq.b    #1,d0        ; next sector #
  511.     cmp.b    d0,d3        ; all sector # set?
  512.     bcc.s    .0        ; if not, continue
  513.                 ; format unit
  514.     move.w    8(sp),d3    ; d3.w = physical unit #
  515.     andi.b    #7,d3        ; mask off flags (if any)
  516.     lsl.b    #4,d3        ; shift physical unit # into place
  517.     move.b    d3,IDESDH    ; set physical unit #
  518.     subq.w    #1,d1        ; dbra likes one less
  519.     subq.w    #1,d2        ; dbra likes one less
  520.     move.w    d2,d3        ; d3 = # heads - 1
  521.     lea    sbuf,a0        ; a0 -> format data
  522. .1:    move.w    d3,d2        ; reinitialize head number for next cylinder
  523. .2:    movem.l    d1-d2/a0,-(sp)    ; save cylinder and head count
  524.     bsr    _fmttrk        ; format track of current cylinder and head
  525.     bne.s    .4        ; if fail, return
  526. .3:    movem.l    (sp)+,d1-d2/a0    ; restore cylinder and head count
  527.     dbra    d2,.2        ; for all heads
  528.     dbra    d1,.1        ; for all cylinders
  529.     moveq    #0,d0        ; everything's fine
  530.     bra.s    .5        ; and return
  531. .4:    adda.l    #12,sp        ; else clean up stack
  532. .5:    move.l    (sp)+,d3    ; restore d3
  533.     rts
  534.  
  535.  
  536.  
  537. ;+
  538. ; setmode() - set the unit to its default mode and return the default
  539. ;        drive parameters.
  540. ;
  541. ; setmode(pdev)
  542. ; WORD    pdev;    $4(sp).w
  543. ;
  544. ; Returns:
  545. ;    d0.w = 0    if successful
  546. ;         = non-0    if failed
  547. ;    d1.w = # of default cylinders
  548. ;    d2.w = # of default heads
  549. ;    d3.w = # of default sectors per track
  550. ;
  551. ; Comments:
  552. ;    This routine distinguishes the Conner drives from other vendors'
  553. ; because Conner saves their default values in a reserved area. (Sigh)
  554. ; Furthermore, since the default parameters are not stored on the Conner 
  555. ; CP2024 (20Mb) drives at all, they are being hardwired into the code. 
  556. ; (I know, it's terrible!)
  557. ;-
  558. setmode:
  559.     pea    sbuf        ; scratch buffer
  560.     move.w    8(sp),-(sp)    ; physical unit #
  561.     bsr    _identify    ; identify(pdev, buf)
  562.     addq.w    #6,sp        ; clean up stack
  563.     tst.w    d0        ; successful?
  564.     bne    smend        ; if not, return
  565.                 ; else 
  566.     lea    sbuf,a1        ; a1 -> data buffer
  567.     move.l    #sbuf+MDLNUM,-(sp)
  568.     pea    conner
  569.     move.w    #6,-(sp)
  570.     bsr    strcmp        ; compare model# with "Conner"
  571.     adda    #10,sp        ; clean up stack
  572.     tst.w    d0        ; is unit a Conner drive?
  573.     bne.s    other        ; if not, handle the normal way
  574.                 ; else
  575.     move.l    #sbuf+CONMDL,-(sp)
  576.     pea    cp2024
  577.     move.w    #6,-(sp)
  578.     bsr    strcmp        ; compare model# with "CP2024"
  579.     adda    #10,sp        ; clean up stack
  580.     tst.w    d0        ; is unit the CP2024 (Kato 20Mb)?
  581.     bne.s    nkato        ; if not, parms at reserved area
  582.                 ; else return default values of CP2024
  583.     move.w    #CP20NCYL,d1    ; d1.w = # of cylinders
  584.     move.w    #CP20NHEAD,d2    ; d2.w = # of heads
  585.     move.w    #CP20NSPT,d3    ; d3.w = # of spt
  586.     bra.s    smend        ; no need to init parm, just return
  587.  
  588.                 ; for other Conner drives
  589. nkato:    move.w    CPNCYL(a1),d1    ; get parameters at Conner
  590.     moveq    #0,d2        ;   reserved location
  591.     move.b    CPNHEAD(a1),d2
  592.     moveq    #0,d3
  593.     move.b    CPNSPT(a1),d3
  594.     bra.s    sminit        ; go do initparm
  595.  
  596. other:    move.w    NCYL(a1),d1    ; d1.w = # of cylinders
  597.     move.w    NHEAD(a1),d2    ; d2.w = # of heads
  598.     move.w    NSPT(a1),d3    ; d3.w = # of sectors per track
  599.  
  600. sminit:    movem.l    d1-d3,-(sp)    ; save drive parameters
  601.     move.w    d3,-(sp)    ; sectors per track
  602.     move.w    d2,-(sp)    ; # of heads
  603.     move.w    20(sp),-(sp)    ; physical unit #
  604.     bsr    _initparm    ; set drive to default mode
  605.     addq.w    #6,sp        ; clean up stack
  606.     movem.l    (sp)+,d1-d3    ; restore drive parameters
  607.  
  608. smend:    rts
  609.  
  610.  
  611. ;+
  612. ; clrsbuf() - clear the scratch buffer
  613. ;-
  614. clrsbuf:
  615.     movem.l    d0/a0,-(sp)    ; save d0 and a0
  616.     lea    sbuf,a0        ; a0 -> scratch buffer
  617.     move.w    #127,d0        ; d0 = counter
  618. .0:    clr.l    (a0)+        ; clear 4 bytes
  619.     dbra    d0,.0        ; repeat until done
  620.     movem.l    (sp)+,d0/a0    ; restore d0 and a0
  621.     rts
  622.  
  623.  
  624. ;+
  625. ; fmttrk() - formats a track with format data provided.
  626. ;
  627. ; Passed:
  628. ;    d1.w = cylinder #
  629. ;    d2.w = head #
  630. ;    a0.l -> format data
  631. ;-
  632.     .globl    _fmttrk
  633. _fmttrk:
  634.     andi.b    #$f0,IDESDH    ; erase previous head #
  635.     or.b    d2,IDESDH    ; set new head #
  636.     move.b    d1,IDECL    ; set cylinder low
  637.     lsr.w    #8,d1        ; d0.b = cylinder high
  638.     move.b    d1,IDECH    ; set cylinder high
  639.     move.b    #0,IDEDOR    ; enable interrupt
  640.  
  641.     tst.b    _useblit    ; use BLiTTER?
  642.     beq.s    .0        ; if not, no need to init it
  643.     moveq    #1,d0        ; write through BLiTTER
  644.     bsr    initblit    ; initialize the BLiTTER
  645.  
  646. .0:    move.b    #FMTTRK,IDECR    ; set command code
  647. .1:    btst.b    #DRQ,IDEASR    ; DRQ?
  648.     beq.s    .1        ; if not, wait longer
  649.  
  650.     bsr    wrtbuf        ; write format data to sector buffer
  651.     bra    w4int
  652.  
  653.  
  654. ;+
  655. ; seek() - initiates a seek to the track and selects the head 
  656. ;       specified in the Task File.
  657. ;
  658. ; seek(pdev, head, cyl)
  659. ; WORD    pdev;    $4(sp).w
  660. ; WORD    head;    $6(sp).w
  661. ; WORD    cyl;    $8(sp).w
  662. ;-
  663.     .globl    _seek
  664. _seek:    move.w    4(sp),d0    ; d0 = physical unit #
  665.     andi.b    #7,d0        ; mask off flags
  666.     lsl.b    #4,d0        ; shift unit # to place
  667.     or.b    7(sp),d0    ; b4 of d0 = drive #; b3-b0 of d0 = head #;
  668.     move.b    d0,IDESDH    ; set drive and head #
  669.     move.b    #0,IDEDOR    ; enable interrupt
  670.     move.b    9(sp),IDECL    ; set cylinder low
  671.     move.b    8(sp),IDECH    ; set cylinder high
  672.     move.b    #SEEK,IDECR    ; set command code
  673.     bra    w4int        ; go wait for interrupt
  674.  
  675.  
  676. ;+
  677. ; diag() - performs the internal diagnostic tests implemented by 
  678. ;       the drive.
  679. ;-
  680.     .globl    _diag
  681. _diag:    move.b    #0,IDEDOR    ; enable interrupt
  682.     move.b    #DIAG,IDECR    ; set command code
  683.     bra    w4int
  684.  
  685.  
  686. ;+
  687. ; initparm() - enables the host to set the head switch and cylinder
  688. ;           increment points for multiple sector operations.
  689. ;
  690. ; initparm(pdev, head, spt)
  691. ; WORD     pdev;    4(sp).w
  692. ; WORD    head;    6(sp).w
  693. ; WORD    spt;    8(sp).w
  694. ;-
  695.     .globl    _initparm
  696. _initparm:
  697.     move.w    4(sp),d0    ; d0 = physical unit #
  698.     andi.b    #7,d0        ; mask off flags
  699.     lsl.w    #4,d0        ; shift it into place
  700.     move.b    d0,IDESDH    ; set physical unit #
  701.     move.w    6(sp),d0    ; d0 = # of heads
  702.     subq.b    #1,d0        ; maximum head #
  703.     or.b    d0,IDESDH    ; set head #
  704.     move.b    9(sp),IDESC    ; set sectors per track
  705.     move.b    #0,IDEDOR    ; enable interrupt
  706.     move.b    #INITPARM,IDECR    ; set command code
  707.     bra    w4int        ; go wait for interrupt
  708.  
  709.  
  710. ;+
  711. ; rsbuf() - allows the Host to read the current contents of the
  712. ;        drive's sector buffer.
  713. ;
  714. ; rsbuf(pdev, buf)
  715. ; WORD    pdev;    4(sp).w
  716. ; BYTE    *buf;    6(sp).l
  717. ;-
  718.     .globl    _rsbuf
  719. _rsbuf:    move.w    4(sp),d0    ; d0 = physical unit #
  720.     andi.b    #7,d0        ; mask off flags (if any)
  721.     lsl.w    #4,d0        ; shift it into place
  722.     move.b    d0,IDESDH    ; set physical unit #
  723.     move.l    6(sp),a0    ; a0 -> buffer
  724.     move.w    #256,d1
  725.  
  726.     tst.b    _useblit    ; BLiTTER exists?
  727.     beq.s    .0        ; if not, don't use it
  728.     moveq    #0,d0        ; it's a read
  729.     bsr    initblit    ; initialize the BLiTTER
  730.  
  731. .0:    move.b    #0,IDEDOR    ; enable interrupt
  732.     move.b    #RSBUF,IDECR    ; set command code
  733.     bsr    w4int        ; go wait for interrupt
  734.     tst.w    d0        ; successful?
  735.     bmi.s    .1        ; if timed-out, return
  736.     btst    #DRQ,d0        ; DRQ?
  737.     beq.s    .1        ; if not, return with error
  738.  
  739.     bsr    readbuf        ; read data
  740.     moveq    #0,d0        ; everything is fine
  741. .1:    rts 
  742.  
  743.  
  744. ;+
  745. ; wsbuf() - allows the Host to overwrite the contents of the drive's
  746. ;        sector buffer.
  747. ;
  748. ; wsbuf(pdev, buf)
  749. ; WORD    pdev;    4(sp).w
  750. ; BYTE    *buf;    6(sp).l
  751. ;-
  752.     .globl    _wsbuf
  753. _wsbuf:    move.w    4(sp),d0    ; d0 = physical unit #
  754.     andi.b    #7,d0        ; mask off flags (if any)
  755.     lsl.w    #4,d0        ; shift it into place
  756.      move.b    d0,IDESDH    ; set physical unit #
  757.     move.l    6(sp),a0    ; a0 -> buffer
  758.     move.w    #256,d0        ; d0 = word count
  759.  
  760.     tst.b    _useblit    ; BLiTTER exists?
  761.     beq.s    .0        ; if not, don't use it
  762.     moveq    #0,d0        ; it's a read
  763.     bsr    initblit    ; initialize the BLiTTER
  764.  
  765. .0:    move.b    #WSBUF,IDECR    ; set command code
  766. .1:    btst    #DRQ,IDESR    ; DRQ?
  767.     beq.s    .1        ; if not, wait some more
  768.  
  769.     bsr    wrtbuf        ; write data
  770.     moveq    #0,d0        ; everything is fine
  771.     rts
  772.  
  773.  
  774. ;+
  775. ; standby() - set drive to Standby mode
  776. ;
  777. ; standby(pdev)
  778. ; WORD    pdev;    4(sp).w        ; physical unit #
  779. ;-
  780.     .globl    _standby
  781. _standby:
  782.     move.w    4(sp),d0    ; d0 = physical unit #
  783.     andi.b    #7,d0        ; mask off flags (if any)
  784.     lsl.b    #4,d0        ; shift unit # to place
  785.     move.b    d0,IDESDH    ; set drive #
  786.     move.b    #STANDBY,IDECR    ; set command code
  787.     bra    w4int        ; go wait for interrupt
  788.  
  789.  
  790. ;+
  791. ; active() - set drive to Active mode
  792. ;
  793. ; active(pdev)
  794. ; WORD    pdev;    4(sp).w        ; physical unit #
  795. ;-
  796.     .globl    _active
  797. _active:
  798.     move.w    4(sp),d0    ; d0 = physical unit #
  799.     andi.b    #7,d0        ; mask off flags (if any)
  800.     lsl.b    #4,d0        ; shift unit # to place
  801.     move.b    d0,IDESDH    ; set drive #
  802.     move.b    #ACTIVE,IDECR    ; set command code
  803.     bra    w4int        ; go wait for interrupt
  804.  
  805.  
  806. ;+
  807. ; sbwto() - set drive to Standby mode with timeout counter (in 5s increments)
  808. ;
  809. ; sbwto(pdev, timeout)
  810. ; WORD    pdev;        4(sp).w        ; physical unit #
  811. ; WORD    timeout;    6(sp).w
  812. ;-
  813.     .globl    _sbwto
  814. _sbwto:    
  815.     move.w    4(sp),d0    ; d0 = physical unit #
  816.     andi.b    #7,d0        ; mask off flags (if any)
  817.     lsl.b    #4,d0        ; shift unit # to place
  818.     move.b    d0,IDESDH    ; set drive #
  819.     move.b    7(sp),IDESC    ; set timeout counter
  820.     move.b    #SBWTO,IDECR    ; set command code
  821.     bra    w4int        ; go wait for interrupt
  822.  
  823.  
  824. ;+
  825. ; ssc() - set sector count wrt current mode of drive
  826. ;
  827. ; ssc(pdev)
  828. ; WORD    pdev;    4(sp).w        ; physical unit #
  829. ;-
  830.     .globl    _ssc
  831. _ssc:    
  832.     move.w    4(sp),d0    ; d0 = physical unit #
  833.     andi.b    #7,d0        ; mask off flags (if any)
  834.     lsl.b    #4,d0        ; shift unit # to place
  835.     move.b    d0,IDESDH    ; set drive #
  836.     move.b    #SSC,IDECR    ; set command code
  837.     bra    w4int        ; go wait for interrupt
  838.  
  839.  
  840. ;+
  841. ; sbres() - set drive to Standby mode.
  842. ;      - drive will not wake up until reset is sent to drive
  843. ;
  844. ; sbres(pdev)
  845. ; WORD    pdev;    4(sp).w        ; physical unit #
  846. ;-
  847.     .globl    _sbres
  848. _sbres:    
  849.     move.w    4(sp),d0    ; d0 = physical unit #
  850.     andi.b    #7,d0        ; mask off flags (if any)
  851.     lsl.b    #4,d0        ; shift unit # to place
  852.     move.b    d0,IDESDH    ; set drive #
  853.     move.b    #SBRES,IDECR    ; set command code
  854.     bra    w4int        ; go wait for interrupt
  855.  
  856.  
  857. ;+
  858. ; slave() - test if the slave drive exists
  859. ;
  860. ; Returns: 0 - if slave does not exist
  861. ;       1 - if slave exists
  862. ;-
  863.     .globl    _slave
  864. _slave:    moveq    #0,d0        ; assume slave does NOT exist
  865.     bset.b    #4,IDESDH    ; set drive bit to 1 (slave)
  866.     btst.b    #DRDY,IDESR    ; is slave ready?
  867.     beq.s    .0        ; if not, no slave
  868.     moveq    #1,d0        ; else, slave exists
  869. .0:    rts
  870.  
  871.  
  872. ;+
  873. ; _iderdy() - test if the IDE drive is ready
  874. ;
  875. ; Passed:
  876. ;    d0.b = IDE drive unit #
  877. ;
  878. ; Returns: 0 - if drive is NOT ready
  879. ;       1 - if drive is ready
  880. ;-
  881.     .globl    _iderdy
  882. _iderdy:
  883.     andi.b    #7,d0        ; mask off flags (if any)
  884.     lsl.b    #4,d0        ; shift unit # to place
  885.     move.b    d0,IDESDH    ; set drive #
  886.     move.b    #$50,d1        ; ready status
  887.     move.l    #IDERDY,d0    ; set up timer
  888.     add.l    _hz_200,d0
  889. ir0:    cmp.b    IDEASR,d1    ; is drive ready and not busy?
  890.     beq.b    ir1        ; if so, return with drive ready
  891.     cmp.l    _hz_200,d0    ; time-out yet?
  892.     bcc.b    ir0        ; if not, wait longer
  893.     moveq    #0,d0        ; else return drive NOT ready
  894.     rts
  895. ir1:    moveq    #1,d0        ; else, drive is ready
  896.     rts
  897.  
  898.  
  899. .data
  900. sbuf:    dcb.b    512,0        ; scratch buffer
  901.  
  902. .endif    ;!DRIVER
  903.  
  904.  
  905.