home *** CD-ROM | disk | FTP | other *** search
/ Shareware Supreme Volume 6 #1 / swsii.zip / swsii / 165 / WDFMT25.ZIP / DISKSTUF.C < prev    next >
Text File  |  1990-06-19  |  20KB  |  687 lines
  1. #include "structs.h"
  2. #include "defs.h"
  3. #include <bkeybrd.h>
  4. #include <bkeys.h>
  5. #include <scancode.h>
  6. #include <color.h>
  7.  
  8. /*  Global variables */
  9.  
  10. extern struct type_htable hd_table;
  11. extern struct type_task_file task_file;
  12. extern struct type_esfile ;
  13. extern union  type_scan scan_code;
  14. extern struct type_error err_table[300];
  15. extern struct type_error defect_table[300];
  16.  
  17.  
  18. extern char far  *wr_buffer[2];
  19. extern char far  *fmt_buffer[16];
  20. extern int command,err_count, defect_count, errcnt,bad_count,redirection,quit;
  21. extern int bad_sector_map[100];
  22. extern unsigned char alt_value;
  23.  
  24. /*************************************/
  25. /*                     */
  26. /*  init_disk()              */
  27. /*                     */
  28. /*  initialize hard disk         */
  29. /*                     */
  30. /*************************************/
  31. init_disk()
  32.  
  33. {                        /* start of init_disk */
  34.    int temp_sdh,i,ii;
  35.    char temp;
  36.    if(hd_table.max_head > 7) temp = 0x0a;
  37.    else temp = 0x02;
  38.  
  39.    outp(temp & 4,0x0e);                /* reset hard drive */
  40.    i= 0;                  // delay 5.0 usec min
  41.    ii = 1;
  42.    while(ii<30)
  43.    {
  44.       i++;
  45.       ii=i;
  46.       ii*=3;
  47.    }
  48.    i=27;
  49.    outp(temp,0x0a);               // turn off reset
  50.  
  51.  
  52.    while(at_ckbsy());                /* check busy bit in controler */
  53.  
  54.    temp_sdh =  (hd_table.max_head & 0xf) +         /* bits 0-3 */
  55.           ((hd_table.drv_number <<4) & 0x10) +     /* bit  4 */
  56.           ((hd_table.sec_size << 5) & 0x60) +     /* bits 5,6 */
  57.           ((hd_table.ecc << 7) & 0x80);         /* bit 7 */
  58.    at_setp(temp_sdh,hd_table.max_sec);        /* set parameters */
  59.    while(at_ckbsy());                /* check busy bit in controler */
  60.    while(at_ckbsy());                /* wait untill drive is ready */
  61.  
  62.    load_task_file();                /* load task file       */
  63.    at_rest(0);                    /* recal drive    */
  64.    while(at_ckbsy());                /* check busy bit in controler */
  65.    while(at_ckbsy());                /* check busy bit in controler */
  66.    load_task_file();                /* load task file        */
  67.    at_rest(0);                    /* restore drive  */
  68.    while(at_ckbsy());                /* check busy bit in controler */
  69.    while(at_ckbsy());                /* check busy bit in controler */
  70.  
  71.    if (at_rstat() & 0x05)               /* check if error for recal */
  72.       show_error();                /* show any errors */
  73.  
  74. }                        /* end of init_disk */
  75.  
  76. /*************************************/
  77. /*                     */
  78. /* should_do_errors()             */
  79. /*                     */
  80. /* find out from user if bad tracks  */
  81. /* should be marked bad then mark    */
  82. /* bad if was "Y" typed.             */
  83. /*                     */
  84. /*************************************/
  85. should_do_errors()
  86.  
  87. {                        /* start of error junk */
  88.    int done;
  89.    unsigned char resp;
  90.    char temp_str[8];
  91.  
  92.  
  93.    do_errors();                /* show errors found in err_table */
  94.    if(err_count <= 0) return;
  95.    printf("\n\nDo you wish to mark these blocks bad? (y/n)");
  96.    done = FALSE;
  97.    while(!done)
  98.    {
  99.       resp = get_input(redirection);               /* get user responce */
  100.       resp = toupper(resp);
  101.       switch(resp)
  102.       {                     /* start of switch */
  103.      case 'Y' : done = TRUE;
  104.             era_eol();
  105.             printf("\nPlease wait...");
  106.             mark_bad_sectors();       /* mark bad sectors*/
  107.             err_count = 0;
  108.             break;
  109.      case 'N' : err_count = 0;
  110.             done = TRUE;
  111.             break;
  112.      default  : BELL;
  113.       }                     /* end of switch */
  114.     }                        /* end while */
  115.     err_count = 0;
  116.  }                        /* end of sould_do_errors */
  117.  
  118.  
  119.  
  120.  
  121. /*************************************/
  122. /*                     */
  123. /* mark bad sectors             */
  124. /*                     */
  125. /*************************************/
  126.  
  127. mark_bad_sectors()
  128. {                       /* start of fmt_bad_track */
  129.  
  130.     int error_val, errcnt, tempc, swap;
  131.     unsigned char temps, temph, tempb;
  132.     int count = 0;
  133.  
  134.     temps = hd_table.sec_number;
  135.     temph = hd_table.head_number;
  136.     tempc = hd_table.cyl_number;
  137.     tempb = hd_table.blk_size;
  138.     hd_table.blk_size = 1;
  139.     for (errcnt = 0; errcnt < err_count; errcnt++)
  140.     {                    /* fmt bad each sector in table */
  141.         hd_table.cyl_number =  err_table[errcnt].cyl;
  142.         hd_table.head_number = err_table[errcnt].head;
  143.         if((hd_table.cyl_number != 0) || (hd_table.head_number != 0)) /* do not mark c:0 h:0 */
  144.         {
  145.            if(err_table[errcnt].sector == 0xff) /* test  if no offset */
  146.           fmt_bad_track();            /* no offset */
  147.            else
  148.           fmt_bad_sector(err_table[errcnt].sector); /* format bad sectorson track */
  149.         }
  150.     }
  151.  
  152.     hd_table.sec_number = temps;
  153.     hd_table.head_number   = temph;
  154.     hd_table.cyl_number    = tempc;
  155.     hd_table.blk_size = tempb;
  156. }                        /* end of fmt_bad_sector */
  157.  
  158.  
  159. /************************************************
  160. **
  161. ** fmt_bad_sector(sector)
  162. **
  163. ** inputs :
  164. **        sector : sector to mark bad
  165. **
  166. ** output : error code
  167. **
  168. ** this routine will find all sectors marked bad then format
  169. ** those sectors bad along with sector as bad
  170. **
  171. *************************************************/
  172. fmt_bad_sector(sector)
  173.  
  174. unsigned char sector;
  175.  
  176. {                        /* start of fmt_bad_sector() */
  177.    unsigned char temp_count,temp_sector;
  178.    int error_val;
  179.  
  180.    temp_count = hd_table.blk_size;
  181.    temp_sector = hd_table.sec_number;
  182.    hd_table.blk_size = 1;
  183.    for(hd_table.sec_number = 1;hd_table.sec_number < hd_table.max_sec;hd_table.sec_number++)
  184.       bad_sector_map[hd_table.sec_number] = test_bad_sector();
  185.    if(hd_table.alt_sector)
  186.    {
  187.       hd_table.sec_number = (int)alt_value;
  188.       if(test_bad_sector())
  189.       {                 /* if alt sector bad then mark track */
  190.      fmt_bad_track();
  191.      return;
  192.        }
  193.    }
  194.    else
  195.    {
  196.       hd_table.sec_number = hd_table.max_sec;
  197.       bad_sector_map[hd_table.max_sec] = test_bad_sector();/* check if maked bad */
  198.    }
  199.    bad_sector_map[sector] = TRUE;
  200.    do_ilt(0,hd_table.head_number);         /* make interleave table */
  201.    set_bad_sectors();
  202.  
  203.    hd_table.blk_size = hd_table.max_sec;    /* set block size */
  204.    hd_table.sec_number = 1;
  205.  
  206.      load_task_file();
  207.      at_fmt();                    /* send format command */
  208.      while(! (0x08 & at_rstat()));        /* wait for data request */
  209.      at_wrbfr(0,fmt_buffer[hd_table.head_number]);
  210.      while(at_ckbsy());             /* check busy bit in controler */
  211.      while(at_ckbsy());             /* check busy bit in controler */
  212.      if ((at_rstat() & 0x05)) fmt_bad_track(); /* format all track bad */
  213.    hd_table.blk_size = temp_count;
  214.    hd_table.sec_number = temp_sector;
  215.    return;
  216. }                        /* end of fmt_bad_sector() */
  217. /***********************************************
  218. **
  219. ** fmt_bad_track()
  220. **
  221. ** inputs : none
  222. **
  223. ** output : error value
  224. **
  225. ** this routine will mark all of the track bad
  226. *************************************************/
  227. fmt_bad_track()
  228.  
  229. {
  230.    unsigned char temp_count,temp_sector;
  231.    int i;
  232.  
  233.    temp_count = hd_table.blk_size;
  234.    temp_sector = hd_table.sec_number;
  235.    do_ilt(0x80,0);
  236.    hd_table.blk_size = hd_table.max_sec;    /* set block size */
  237.    hd_table.sec_number = 1;
  238.      load_task_file();
  239.      at_fmt();                    /* send format command */
  240.      while(! (0x08 & at_rstat()));        /* wait for data request */
  241.      at_wrbfr(0,fmt_buffer[0]);
  242.      while(at_ckbsy());             /* check busy bit in controler */
  243.      while(at_ckbsy());             /* check busy bit in controler */
  244.    hd_table.blk_size = temp_count;
  245.    hd_table.sec_number = temp_sector;
  246. }
  247.  
  248.  
  249. /************************************************
  250. **
  251. ** set_bad_sectors()
  252. **
  253. ** inputs : none
  254. **
  255. ** output : none
  256. **
  257. ** this routine will update interleave table for bad sectors
  258. **
  259. *************************************************/
  260. set_bad_sectors()
  261.  
  262.  
  263. {                        /* start of set_bad_sectors() */
  264.    int offset, temp_offset;
  265.    unsigned char last_offset, last_sector, sector;
  266.  
  267.    if(hd_table.alt_sector) last_sector = hd_table.max_sec -1;
  268.    else last_sector = hd_table.max_sec;
  269.    last_offset = last_sector * 2;
  270.    for(sector = 1; sector <= last_sector; sector++)
  271.    {                        /* start of check each sector */
  272.       if(bad_sector_map[sector])
  273.       {                     /* if sector to be marked bad */
  274.      for(offset = 0; offset < last_offset; offset += 2)
  275.      if(*(fmt_buffer[hd_table.head_number] + offset + 1) == sector)
  276.      {                    /* mark this sector bad */
  277.         *(fmt_buffer[hd_table.head_number] + offset) = 0x80;
  278.         break;
  279.      }
  280.       }
  281.    }                        /* end of check each sector */
  282.    if(hd_table.alt_sector)
  283.    {                        /* swap alt_value with bad value */
  284.       for(temp_offset = last_offset-2; temp_offset >= offset; temp_offset -= 2)
  285.      /* shift sector number */
  286.      *(fmt_buffer[hd_table.head_number]+temp_offset+3) =
  287.         *(fmt_buffer[hd_table.head_number]+temp_offset+1);
  288.       *(fmt_buffer[hd_table.head_number] + offset + 1) = alt_value; /*put alt_value on bad sector */
  289.    }                        /* end of if alt sector */
  290. }                        /* end of set_bad_sector() */
  291.  
  292. /**************************************
  293. **
  294. ** test_bad_sector()
  295. **  inputs : none
  296. **  output :
  297. **         TRUE : sector is bad
  298. **         FALSE: sector is ok
  299. **
  300. ** this routine will test a single sector
  301. ***************************************/
  302. test_bad_sector()
  303. {
  304.        load_task_file();
  305.        at_rdver(1);                /* do that verify with out retry */
  306.        while(at_ckbsy());            /* check busy bit in controler */
  307.        while(at_ckbsy());            /* check busy bit in controler */
  308.  
  309.        if(at_rstat() & 0x05)  return (TRUE);       /* if error */
  310.        return(FALSE);
  311. }
  312. /*************************************/
  313.  
  314.  
  315.  
  316. #define BOTTOM 20
  317. #define TOP    10
  318. #define COL_C  20
  319. #define COL_H  40
  320. #define COL_O  60
  321. #define WINDOW 1,TOP,BOTTOM,1,79,7
  322.  
  323. /*************************************/
  324. /*                     */
  325. /* enter_bad_map()             */
  326. /*                     */
  327. /* user can enter bad track map from */
  328. /* keyboard.                 */
  329. /*                     */
  330. /*************************************/
  331. enter_bad_map()
  332.  
  333. {                        /* start of enter_bad_map() */
  334.    int done,in_valid;
  335.    int temp, i, j, max_i, row, col, in_key;
  336.    unsigned char in_char;
  337.  
  338.    cls();
  339.    curs(1,1);
  340.    printf("\n\nYou may now enter additional areas to be marked bad.");
  341.    printf("\nEnter cylinder number <CR> head number <CR> and offset <CR> ");
  342.    printf("\n  Use  \x18  \x19  ->  <-  PgUP  PgDn   to move curser ");
  343.    printf("\n  Use ESC to exit without marking,  M to mark bad spots on drive");
  344.    curs(8,10);printf("Enter  <cylinder#>            <head#>              <offset> ");
  345.  
  346.    for(i=0; i<=hd_table.max_head; i++)
  347.       do_ilt(0,i);            /* set up interleave for good blocks */
  348.  
  349.  
  350.    for(i = 0; i < 300; i++)
  351.    {                        /*clear table */
  352.       err_table[i].cyl = 0;
  353.       err_table[i].head = 0;
  354.       err_table[i].sector = 0xff;
  355.       err_table[i].offset = 0;
  356.    }
  357.    i = 0;
  358.    max_i = 0;
  359.    row = TOP;col = COL_C;
  360.    curs(row,col);
  361.    done = FALSE;
  362.    while(!done)
  363.    {                        /* start of while */
  364.       in_char = kbgetkey(&in_key);
  365.       switch(in_key)
  366.       {                     /* start of switch */
  367.      case KB_S_N_DOWN:            /* down arrow */
  368.         if(i > max_i) break;        /* if last entry */
  369.         i++;
  370.         if(row == BOTTOM)
  371.         {                    /* print new line */
  372.            upscroll(WINDOW);
  373.            if(i < max_i)
  374.            {
  375.           curs(row,COL_C);printf("%4d",err_table[i].cyl   );
  376.           curs(row,COL_H);printf("%4d",err_table[i].head  );
  377.           curs(row,COL_O);printf("%6d",err_table[i].offset);
  378.            }
  379.  
  380.         }
  381.         else row++;
  382.         curs(row,col+3);
  383.         break;
  384.      case KB_S_N_UP :            /* up arrow */
  385.         if(i == 0) break;
  386.         i--;
  387.         if(row == TOP)
  388.         {
  389.            downscroll(WINDOW);
  390.            curs(row,COL_C);printf("%4d",err_table[i].cyl   );
  391.            curs(row,COL_H);printf("%4d",err_table[i].head  );
  392.            curs(row,COL_O);printf("%6d",err_table[i].offset);
  393.         }
  394.         else row--;
  395.         curs(row,col+3);
  396.         break;
  397.      case KB_S_N_PGDN:            /* page down */
  398.         j = BOTTOM - row;            /* is there a page full page after this */
  399.         if((i+j) > max_i)
  400.         {                    /* if last page */
  401.            row += max_i - i;
  402.            i = max_i;
  403.            curs(row,col);
  404.            break;
  405.         }
  406.         i += BOTTOM - row; row = BOTTOM;
  407.         for(j = 0; (j < (BOTTOM - TOP+1)) && (i < (max_i-1)); j++)
  408.         {
  409.            ++i;
  410.            upscroll(WINDOW);
  411.            curs(row,COL_C);printf("%4d",err_table[i].cyl   );
  412.            curs(row,COL_H);printf("%4d",err_table[i].head  );
  413.            curs(row,COL_O);printf("%6d",err_table[i].offset);
  414.         }
  415.         curs(row,col+3);
  416.         break;
  417.      case KB_S_N_PGUP:            /* page up */
  418.         if(i == 0) break;
  419.         i -= row - TOP;
  420.         row = TOP;
  421.         for(j = 0; (j < (BOTTOM - TOP)) && (i > 0); j++)
  422.         {
  423.            --i;
  424.            downscroll(WINDOW);
  425.            curs(row,COL_C);printf("%4d",err_table[i].cyl   );
  426.            curs(row,COL_H);printf("%4d",err_table[i].head  );
  427.            curs(row,COL_O);printf("%6d",err_table[i].offset);
  428.         }
  429.         curs(row,col+3);
  430.         break;
  431.      case KB_S_N_RIGHT :            /* right arrow */
  432.         switch(col)
  433.         {                    /* switch on col */
  434.            case COL_C: col = COL_H;     /* if at cyl */
  435.           break;
  436.            case COL_H: col = COL_O;     /* if at head */
  437.           break;
  438.            case COL_O: col = COL_C;     /* if at offset */
  439.           break;
  440.         }
  441.         curs(row,col+3);
  442.         break;
  443.      case KB_S_N_LEFT:            /* left arrow */
  444.         switch(col)
  445.         {                    /* switch on col */
  446.            case COL_C: col = COL_O;     /* if at cyl */
  447.           break;
  448.            case COL_H: col = COL_C;     /* if at head */
  449.           break;
  450.            case COL_O: col = COL_H;     /* if at offset */
  451.           break;
  452.         }
  453.         curs(row,col+3);
  454.         break;
  455.      case KB_S_N_ESC:
  456.      case KB_S_N_Q:             /* duit or escape */
  457.         done = TRUE;
  458.         break;
  459.      case KB_S_N_M:             /* case mark bad sectors */
  460.         curs(24,30);printf("Please wait");
  461.         err_count = max_i;
  462.         mark_bad_sectors();         /* mark sectors as bad */
  463.         curs(24,30);printf("            ");
  464.         done = TRUE;
  465.         break;
  466.      default:                /* probly a number */
  467.         kbplace(1,in_char,in_key);        /* put char back into buffer */
  468.         switch(col)
  469.         {                    /* switch on col */
  470.            case COL_C:            /* if at cyl */
  471.           in_valid = TRUE;
  472.           while(in_valid)        /* get cyl number */
  473.           {
  474.               temp = get_dec(row,COL_C-1,4,err_table[i].cyl); /* get cyl number */
  475.               if((0 <= temp) AND (temp <= hd_table.max_cyl))
  476.              in_valid = FALSE;
  477.               if(in_valid) BELL;
  478.           }
  479.           err_table[i].cyl = temp;
  480.           col = COL_H;
  481.           curs(row,col+3);
  482.           break;
  483.            case COL_H:            /* if at head */
  484.           in_valid = TRUE;
  485.           while(in_valid)
  486.           {                /* start of if valid */
  487.              temp = get_dec(row,COL_H+1,2,err_table[i].head); /* get head number */
  488.              if((0 <= temp) AND (temp <= hd_table.max_head))
  489.             in_valid = FALSE;
  490.              if(in_valid) BELL;
  491.           }                /* end while valid */
  492.           err_table[i].head = (unsigned char)(temp & 0xff);
  493.           col = COL_O;
  494.           curs(row,col+4);
  495.           break;
  496.            case COL_O:            /* if at offset */
  497.           in_valid = TRUE;
  498.           while(in_valid)
  499.           {                /* start of if valid */
  500.              temp = get_dec(row,COL_O-1,6,err_table[i].offset); /* byte offset */
  501.              if(0 <= temp) in_valid = FALSE;
  502.              if(in_valid) BELL;
  503.           }                /* end while valid */
  504.           err_table[i].offset = temp;
  505.           err_table[i].sector =
  506.             *(fmt_buffer[err_table[i].head]+((temp/577)*2)+1); /* get sector number */
  507.           if(temp == 0) err_table[i].sector = 0xff; /* if no offset */
  508.           col = COL_C;            /* adjust screen */
  509.           i++;                /* next entry */
  510.           if(row == BOTTOM)
  511.           {
  512.              upscroll(WINDOW);
  513.              if(i < max_i)
  514.              {
  515.              curs(row,COL_C);printf("%4d",err_table[i].cyl   );
  516.              curs(row,COL_H);printf("%4d",err_table[i].head  );
  517.              curs(row,COL_O);printf("%6d",err_table[i].offset);
  518.              }
  519.           }
  520.           else row++;
  521.           if(max_i < i) max_i = i;
  522.           if(i>=298)
  523.           {
  524.              curs(23,5);printf("You must Mark errors as bad before going on.");
  525.           }
  526.           if(max_i < i) max_i = i;
  527.           curs(row,col+3);
  528.           break;
  529.         }                    /* end switch on col */
  530.         break;
  531.       }                     /* end switch on in_char */
  532.    }                        /* end while */
  533. }                        /* end enter bad_map() */
  534.  
  535. /*************************************/
  536. /*                     */
  537. /* display errors found in error table*/
  538. /*                     */
  539. /*************************************/
  540.  
  541. do_errors()
  542. {
  543.     cls();
  544.     curs(1,1);
  545.     if(err_count <= 0) return;
  546.     printf("Errors will be marked at the following cylinder/head/sector locations:");
  547.     printf("\n");
  548.     for (errcnt = 0; errcnt < err_count; errcnt++)
  549.     {
  550.         if ((errcnt % 5) == 0) printf ("\n");
  551.         printf("    %4d/%2d/%2d", err_table[errcnt].cyl,
  552.             err_table[errcnt].head,err_table[errcnt].sector);
  553.     }
  554. }
  555. /* ***************************************
  556. **
  557. ** show_defect_list
  558. **
  559. ** inputs : none
  560. **
  561. ** output : none
  562. **
  563. ** display previously marked bad sectors
  564. ******************************************/
  565. show_defect_list()
  566. {
  567.     cls();
  568.     if(defect_count <= 0) return;
  569.     curs(1,1);
  570.     printf("Sectors that were found marked bad  cylinder/head/sector:");
  571.     printf("\n\n");
  572.     for (errcnt = 0; errcnt < defect_count; errcnt++)
  573.     {
  574.         if ((errcnt % 5) == 0) printf ("\n");
  575.         printf("    %4d/%2d/%2d", defect_table[errcnt].cyl,
  576.             defect_table[errcnt].head,defect_table[errcnt].sector);
  577.     }
  578.     printf("\n\nPress any key to continue");
  579.     getch();
  580. }
  581. /*************************************/
  582. /*                     */
  583. /* make block mark and sector #      */
  584. /* for one track             */
  585. /*                     */
  586. /*************************************/
  587.  
  588. do_ilt(block_mark,head)
  589.  
  590. char block_mark;
  591. int  head;
  592.  
  593. {
  594.  
  595.    int count, ileave, maxcnt;
  596.    unsigned char temp;
  597.    char far *p;
  598.    long offset;
  599.  
  600.    p = fmt_buffer[head];
  601.    for( count=0; count < 512; count++ )
  602.       *p++ = 0xff;                /* fill buffer with 0xFF */
  603.    ileave = hd_table.ileave;            /* set up vars for loop */
  604.    count = 0;
  605.    if(hd_table.alt_sector) maxcnt = hd_table.max_sec-1;
  606.    else maxcnt = hd_table.max_sec;
  607.    offset = (long)((hd_table.skew*head)%maxcnt);    /* clear offset */
  608.  
  609.    while ( count < maxcnt )
  610.    {
  611.       for( ;(unsigned char)*(fmt_buffer[head]+(offset*2)) != 0xFF; offset++); /* inc offset if overlap*/
  612.       p = fmt_buffer[head] + ( offset * 2 );
  613.       *p++ = block_mark;            /* block mark */
  614.       *p = 1+(count % maxcnt);        /* sector number */
  615.       offset +=(long)ileave;             /* inc offset by interleave */
  616.       offset = offset%(long)maxcnt;        /* loop offset */
  617.       count++;
  618.    }                        /* end of while */
  619.    if(hd_table.alt_sector)            /* if need alt sector */
  620.    {
  621.       p = fmt_buffer[head] + (maxcnt * 2);
  622.       *p++ = block_mark;            /* block mark */
  623.       *p = 0;                    /* sector number*/
  624.     }
  625. }
  626.  
  627.  
  628.  
  629. /*************************************/
  630. /*                     */
  631. /* set up task file and load it      */
  632. /*                     */
  633. /*************************************/
  634.  
  635. load_task_file()
  636.  
  637. {
  638.  
  639.     task_file.error  = hd_table.precomp;
  640.     task_file.secnt  = hd_table.blk_size;
  641.     task_file.sector = hd_table.sec_number;
  642.     task_file.cyllo  = (hd_table.cyl_number % 256);
  643.     task_file.cylhi  = (hd_table.cyl_number / 256);
  644.     task_file.SDH     = (hd_table.head_number & 0xf) +     /* bits 0-3 */
  645.                ((hd_table.drv_number <<4) & 0x10) +  /* bit  4 */
  646.                ((hd_table.sec_size << 5) & 0x60) +     /* bits 5,6 */
  647.                (hd_table.ecc << 7);          /* bit 7 */
  648.     at_wtskf(&task_file);
  649. }
  650.  
  651. /*************************************/
  652. /*                     */
  653. /* display errors from reisters      */
  654. /*                     */
  655. /*************************************/
  656.  
  657. show_error()
  658.  
  659. {
  660.     curs(22,1);
  661.     printf("   Error!!... Cyl. %4d   Head %2d  Status  %2x  Error  %2x",
  662.         hd_table.cyl_number, hd_table.head_number,
  663.         at_rstat(), at_rderr());
  664. }
  665.  
  666. /*************************************/
  667. /*                     */
  668. /* dimp 5 lines of buffer to screen  */
  669. /*                     */
  670. /*************************************/
  671.  
  672. dump_5lines(buffer)
  673.  
  674. char *buffer;
  675.  
  676. {
  677.     int num_bytes, count;
  678.  
  679.     for (count = 0; count < 80; count++)
  680.     {
  681.         if ((count % 16) == 0)
  682.             printf("\n%04x    ", count);
  683.         printf("%02x  ", buffer[count]);
  684.     };
  685.     printf("\n");
  686. }
  687.