home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / diskutil / noahdi / hd_front.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-05  |  5.7 KB  |  170 lines
  1. /*
  2.     File: HD_FRONT.C      Front End for Harddisk Driver. AHDI Compatible.
  3. */
  4. /*
  5. Copyright (c) 1988 - 1991 by Ted Schipper.
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation.
  12.  
  13. This software is provided AS IS with no warranties of any kind.  The author
  14. shall have no liability with respect to the infringement of copyrights,
  15. trade secrets or any patents by this file or any part thereof.  In no
  16. event will the author be liable for any lost revenue or profits or
  17. other special, indirect and consequential damages.
  18. */
  19.  
  20. #include "hddriver.h"
  21.  
  22. /***************************************************************************
  23.  
  24.                             Front End
  25.                            -----------
  26.  HISTORY
  27. ---------
  28.  Feb 1989. THS. Started. Tested together with installer.
  29.                 V0.00
  30.  
  31. ***************************************************************************/
  32.  
  33.  
  34. /***************************************************************************
  35.  
  36.                           Global Variables
  37.  
  38. ***************************************************************************/
  39.  
  40. extern struct hd_drv pun[];  /* partition info */
  41.  
  42. /* Initialize variables to get them into the driver code */
  43.  
  44. func  o_init = 0;            /* ptr to old hd_init function */
  45. func  o_bpb = 0;             /* ptr to old hd_bpb function */
  46. func  o_rw = 0;              /* ptr to old hd_rw function */
  47. func  o_mediach = 0;         /* ptr to old hd_mediach function */
  48. short puns = 0;              /* number of harddisk drives attached */
  49.  
  50.  
  51. /***************************************************************************
  52.  *
  53.  * Function name : hbpb. Return pointer to BPB of device.
  54.  * Parameters    : short device. Logical device number.
  55.  * Returns       : long. pointer to logical device BPB
  56.  * Description   : Check if the device belongs to our driver. If true,
  57.  *                 call the sasi_bpb() function. If not our device, pass
  58.  *                 the call to the old function.
  59.  * Comments      : 
  60.  */
  61.  
  62. long hbpb(dev)
  63.  
  64.  short dev;
  65.  
  66. {
  67.  if (check_dev(dev,0) == TRUE)     /* our device */
  68.     return(sasi_bpb(dev));         /* yes, do our function */
  69.  else
  70.     return((*o_bpb)(dev));         /* no, do old function */
  71. }
  72.  
  73.  
  74. /***************************************************************************
  75.  *
  76.  * Function name : hrw. Read/write of a device.
  77.  * Parameters    : short rwflags. Read/write flags:
  78.  *                                bit 0: 0 = read, 1 = write
  79.  *                                bit 1: media change. not used yet.
  80.  *                                bit 2: 0 = with retries, 1 = no retries
  81.  *                                bit 3: 0 = logical, 1 = physical operation
  82.  *                 long  buffer.  Address of buffer.
  83.  *                 short count.   Number of sectors to read/write.
  84.  *                 short recno.   Start sector number.
  85.  *                 short device.  Logical device number.
  86.  * Returns       : long. status of operation.
  87.  * Description   : Check if the device belongs to our driver. If true,
  88.  *                 call the sasi_rw() function. If not our device, pass
  89.  *                 the call to the old function.
  90.  * Comments      : 
  91.  */
  92.  
  93. long hrw(flags,buf,count,recno,dev)
  94.  
  95. short flags;
  96. long  buf;
  97. short count;
  98. short recno;
  99. short dev;
  100.  
  101. {
  102.  if (check_dev(dev,flags) == TRUE)               /* our device */
  103.     return(sasi_rw(flags,buf,count,recno,dev));  /* yes, do our function */
  104.  else
  105.     return((*o_rw)(flags,buf,count,recno,dev));  /* no, do old function */
  106. }
  107.  
  108.  
  109. /***************************************************************************
  110.  *
  111.  * Function name : hmediach. Check if media has changed.
  112.  * Parameters    : short device. Logical device number.
  113.  * Returns       : long. status, allways 0L if ours.
  114.  * Description   : Check if the device belongs to our driver. If true,
  115.  *                 call the sasi_mediach() function. If not our device, pass
  116.  *                 the call to the old function.
  117.  * Comments      : If device belongs to our driver, no media change (0L) is
  118.  *                 returned. We assume harddisk media does not change.
  119.  */
  120.  
  121. long hmediach(dev)
  122.  
  123. short dev;
  124.  
  125. {
  126.  if (check_dev(dev,0) == TRUE)    /* our device */
  127.     return(sasi_mediach(dev));    /* yes, do our function */
  128.  else
  129.     return((*o_mediach)(dev));    /* no, do old function */
  130. }
  131.  
  132.  
  133. /***************************************************************************
  134.  *
  135.  * Function name : check_dev. Check if device belongs to this driver.
  136.  * Parameters    : short device.  Logical device number.
  137.  *                 short rwflags. Read/write flags.
  138.  * Returns       : short. TRUE  = our device.
  139.  *                        FALSE = not our device.
  140.  * Description   : Check if the device belongs to this driver.
  141.  * Comments      : 
  142.  */
  143.  
  144. short check_dev(dev,flags)
  145.  
  146.  short dev;
  147.  short flags;
  148.  
  149. {
  150.  if ((flags & PHYSOP_FLAG))      /* physical operation */
  151.  {
  152.     dev -= 2;                    /* map to physical device */
  153.     if (dev < 0)                 /* not a legal device anymore */
  154.        return(FALSE);            /* not our drive */
  155.     else                         /* still a legal device */
  156.        if (dev >= puns)          /* do we have that many physical drives */
  157.           return(FALSE);         /* no, then not ours */
  158.        else                      /* we have that many drives */
  159.           return(TRUE);          /* tell that it is our drive */
  160.  }
  161.  else                            /* logical operation */
  162.  {
  163.     if (pun[dev].dev_addr >= 0)  /* drive availible, -1 if not */
  164.        return(TRUE);             /* yes, its ours */
  165.     else
  166.        return(FALSE);            /* no, not our drive */
  167.  }
  168. }
  169.  
  170.