home *** CD-ROM | disk | FTP | other *** search
/ Openstep 4.2 (Developer) / Openstep Developer 4.2.iso / NextDeveloper / Examples / DriverKit / Adaptec1542B / Adaptec1542B_reloc.tproj / AHARoutines.m < prev    next >
Encoding:
Text File  |  1996-04-05  |  5.2 KB  |  276 lines
  1. /*
  2.  * Copyright (c) 1992-1996 NeXT Software, Inc.
  3.  *
  4.  * AHARoutines.c - low-level I/O routines for Adaptec 1542 driver. 
  5.  *
  6.  * HISTORY
  7.  *
  8.  * 13 Apr 1993    Doug Mitchell at NeXT
  9.  *    Split off from AHAController.m.
  10.  */
  11.  
  12. #import "AHATypes.h"
  13. #import "AHAInline.h"
  14. #import "AHAThread.h"
  15. #import "AHAControllerPrivate.h"
  16. #import <driverkit/generalFuncs.h>
  17. #import <driverkit/kernelDriver.h>
  18.  
  19.  
  20. void aha_start_scsi(
  21.     unsigned short     base
  22. )
  23. {
  24.     aha_stat_reg_t    stat;
  25.  
  26.     do {
  27.         stat = aha_get_stat(base);
  28.     } while (stat.dataout_full);
  29.  
  30.     aha_put_cmd(base, AHA_CMD_START_SCSI);
  31. }
  32.  
  33.  
  34. boolean_t aha_probe_cmd(
  35.     unsigned short    base,
  36.     unsigned char    cmd,
  37.     unsigned char    *args,
  38.     int        arglen,
  39.     unsigned char    *reply,
  40.     int        replylen,
  41.     boolean_t    polled
  42. )
  43. {
  44.     aha_stat_reg_t    stat;
  45.     aha_intr_reg_t    intr;
  46.     boolean_t    success = FALSE;
  47.     int        fail_count = 100000;
  48.  
  49.     do {
  50.         stat = aha_get_stat(base);
  51.     } while (stat.dataout_full && fail_count--);
  52.     if (fail_count <= 0) 
  53.         return FALSE;
  54.  
  55.     aha_put_cmd(base, cmd);
  56.  
  57.     while (arglen-- > 0) {
  58.         fail_count = 100000;
  59.         do {
  60.             intr = aha_get_intr(base);
  61.             stat = aha_get_stat(base);
  62.             if (intr.cmd_done && stat.cmd_err)
  63.                 goto out;
  64.         } while (stat.dataout_full && fail_count--);
  65.         if (fail_count <= 0) 
  66.             return FALSE;
  67.  
  68.         aha_put_cmd(base, *args++);
  69.     }
  70.  
  71.     while (replylen-- > 0) {
  72.         fail_count = 100000;
  73.         do {
  74.             intr = aha_get_intr(base);
  75.             stat = aha_get_stat(base);
  76.             if (intr.cmd_done && stat.cmd_err)
  77.                 goto out;
  78.         } while (!stat.datain_full && fail_count--);
  79.         if (fail_count <= 0)
  80.             return FALSE;
  81.  
  82.         *reply++ = aha_get_cmd(base);
  83.     }
  84.     success = TRUE;
  85.  
  86.     fail_count = 100000;
  87.     if (polled) do {
  88.         intr = aha_get_intr(base);
  89.     } while (!intr.cmd_done && fail_count--);
  90.     if (fail_count <= 0) 
  91.         success = FALSE;
  92.  
  93. out:
  94.     if (polled)
  95.         aha_clr_intr(base);
  96.  
  97.     return (success);
  98. }
  99.  
  100. boolean_t aha_cmd(
  101.     unsigned short    base,
  102.     unsigned char    cmd,
  103.     unsigned char    *args,
  104.     int        arglen,
  105.     unsigned char    *reply,
  106.     int        replylen,
  107.     boolean_t    polled
  108. )
  109. {
  110.     aha_stat_reg_t    stat;
  111.     aha_intr_reg_t    intr;
  112.     boolean_t        success = FALSE;
  113.     
  114.     do {
  115.         stat = aha_get_stat(base);
  116.     } while (stat.dataout_full);
  117.  
  118.     aha_put_cmd(base, cmd);
  119.  
  120.     while (arglen-- > 0) {
  121.         do {
  122.             intr = aha_get_intr(base);
  123.             stat = aha_get_stat(base);
  124.             if (intr.cmd_done && stat.cmd_err) 
  125.                 goto out;
  126.         } while (stat.dataout_full);
  127.     
  128.         aha_put_cmd(base, *args++);
  129.     }
  130.  
  131.     while (replylen-- > 0) {
  132.         do {
  133.             intr = aha_get_intr(base);
  134.             stat = aha_get_stat(base);
  135.             if (intr.cmd_done && stat.cmd_err)
  136.                 goto out;
  137.         } while (!stat.datain_full);
  138.     
  139.         *reply++ = aha_get_cmd(base);
  140.     }
  141.     success = TRUE;
  142.     
  143.     if (polled) do {
  144.         intr = aha_get_intr(base);
  145.     } while (!intr.cmd_done);
  146.  
  147. out:
  148.     if (polled)
  149.         aha_clr_intr(base);
  150.     
  151.     return (success);
  152. }
  153.  
  154.  
  155. void aha_reset_board(
  156.     unsigned short     base, 
  157.     unsigned char     aha_board_id
  158. ) 
  159. {
  160.  
  161.     aha_ctrl_reg_t    ctrl = { 0 };
  162.     aha_stat_reg_t    stat;
  163.  
  164.     ctrl.sw_rst = 1;
  165.  
  166.     aha_put_ctrl(base, ctrl);
  167.  
  168.     /* Avoid a 174x standard mode firmware bug */
  169.     if (aha_board_id == AHA_174xA) {
  170.         do {
  171.             stat = aha_get_stat(base);
  172.         } while (!stat.idle);
  173.         IOSleep(500);
  174.     }
  175.     else {
  176.         do {
  177.             stat = aha_get_stat(base);
  178.         } while (!stat.idle || !stat.mb_init_needed);
  179.     }
  180.  
  181.     aha_clr_intr(base);
  182. }
  183.  
  184. boolean_t aha_setup_mb_area(
  185.     unsigned short         base,
  186.     struct aha_mb_area     *ahaMbArea,
  187.     struct ccb         *ahaCcb
  188. )
  189. {
  190.     aha_cmd_init_t    init;
  191.     int            i;
  192.     unsigned        *mbPhysAddr;
  193.     IOReturn        rtn;
  194.     aha_mb_t        *mbOutVirt;
  195.     aha_mb_t        *mbInVirt;
  196.     struct ccb        *ccbPhys;
  197.     struct ccb        *ccbVirt;
  198.  
  199.     ddm_init("AHAController aha_setup_mb_area\n", 1,2,3,4,5);
  200.    
  201.     rtn = IOPhysicalFromVirtual(IOVmTaskSelf(),
  202.         (vm_address_t)ahaMbArea,
  203.         (unsigned *)&mbPhysAddr);
  204.     if(rtn) {
  205.         IOLog("AHAController: Can't get physical address of "
  206.             "ahaMbArea (%s)\n", [IODevice stringFromReturn:rtn]);
  207.         return FALSE;
  208.     }
  209.     aha_unlock_mb(base);
  210.  
  211.     init.mb_cnt = AHA_MB_CNT;
  212.     aha_put_24((vm_offset_t)mbPhysAddr, init.mb_area_addr); 
  213.  
  214.     if (!aha_cmd(base,
  215.         AHA_CMD_INIT, (unsigned char *)&init, sizeof (init),
  216.         0, 0, TRUE)) {
  217.         IOLog("aha at %x: mb_init failed\n", base);
  218.         return (FALSE);
  219.     }
  220.  
  221.     /*
  222.      * Setup CCBs and mailboxes. The CCB pointers in the mb_out mailboxes 
  223.      * have to be physical addresses; the mb_out pointer in the ccb is a 
  224.      * virtual address.
  225.      */
  226.     mbOutVirt = &ahaMbArea->mb_out[0];
  227.     mbInVirt = &ahaMbArea->mb_in[0];
  228.     ccbVirt = ahaCcb;
  229.     
  230.     for (i = 0; i < AHA_MB_CNT; i++) {
  231.     
  232.         mbOutVirt->mb_stat = AHA_MB_OUT_FREE;
  233.         mbInVirt->mb_stat  = AHA_MB_IN_FREE;
  234.         ccbVirt->mb_out    = mbOutVirt;
  235.  
  236.         rtn = IOPhysicalFromVirtual(IOVmTaskSelf(),
  237.             (vm_address_t)ccbVirt,
  238.             (unsigned *)&ccbPhys);
  239.         if(rtn) {
  240.             IOLog("AHAController: Can't get physical address of "
  241.             "ccb (%s)\n", [IODevice stringFromReturn:rtn]);
  242.             return FALSE;
  243.         }
  244.         ddm_init("ccbPhys[%d] = 0x%x\n", i, ccbPhys, 3,4,5);
  245.         
  246.         aha_put_24((vm_offset_t) ccbPhys, mbOutVirt->ccb_addr);
  247.     
  248.         mbOutVirt++;
  249.         mbInVirt++;
  250.         ccbVirt++;
  251.     }
  252.     
  253.     return (TRUE);
  254. }
  255.  
  256. void aha_unlock_mb(
  257.     unsigned short     base
  258. )
  259. {
  260.     aha_mb_lock_t    lock;
  261.  
  262.     /*
  263.      * Unlock the mailbox interface in case extended
  264.      * BIOS translation was used.
  265.      */
  266.     if(!aha_probe_cmd(base, AHA_CMD_GET_BIOS_INFO,
  267.         0, 0, (unsigned char*)&lock, sizeof(lock), TRUE)) {
  268.             return;
  269.     }
  270.  
  271.     lock.mb_status = 0;
  272.     aha_probe_cmd(base, AHA_CMD_SET_MB_ENABLE,
  273.         (unsigned char *)&lock, sizeof(lock), 0, 0, TRUE);
  274. }
  275.  
  276.