home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / dskutl / wd.arc / DISKSTUF.C < prev    next >
Text File  |  1987-10-02  |  9KB  |  318 lines
  1. #include <\c_ms\include\structs.h>
  2. #include <\c_ms\include\defs.h>
  3. #include <\c_ms\include\scancode.h>
  4. #include <\c_ms\include\color.h>
  5.  
  6. /*  Global variables */
  7.  
  8. extern struct type_htable hd_table;
  9. extern struct type_task_file task_file;
  10. extern struct type_esfile ;
  11. extern union  type_scan scan_code;
  12. extern struct type_error err_table[100];
  13.  
  14. extern char *rd_buffer, *wr_buffer, *fmt_buffer;
  15. extern int command,err_count, errcnt,bad_count,redirection,quit;
  16. extern char head_buf[16][buf_length];
  17. extern unsigned char alt_value;
  18.  
  19. /*************************************/
  20. /*                     */
  21. /*  init_disk()              */
  22. /*                     */
  23. /*  initialize hard disk         */
  24. /*                     */
  25. /*************************************/
  26. init_disk()
  27.  
  28. {                        /* start of init_disk */
  29.    int temp_sdh;
  30.  
  31.    at_reset();                    /* reset hard drive */
  32.    while(at_ckbsy());                /* check busy bit in controler */
  33.    while(at_ckbsy());                /* wait untill drive is ready */
  34.  
  35.    temp_sdh =  (hd_table.max_head & 0xf) +         /* bits 0-3 */
  36.           ((hd_table.drv_number <<4) & 0x10) +     /* bit  4 */
  37.           ((hd_table.sec_size << 5) & 0x60) +     /* bits 5,6 */
  38.           ((hd_table.ecc << 7) & 0x80);         /* bit 7 */
  39.    at_setp(temp_sdh,hd_table.max_sec);        /* set parameters */
  40.    while(at_ckbsy());                /* check busy bit in controler */
  41.    while(at_ckbsy());                /* wait untill drive is ready */
  42.  
  43.    load_task_file();                /* load task file       */
  44.    at_rest(0);                    /* recal drive    */
  45.    while(at_ckbsy());                /* check busy bit in controler */
  46.    while(at_ckbsy());                /* check busy bit in controler */
  47.    load_task_file();                /* load task file        */
  48.    at_rest(0);                    /* restore drive  */
  49.    while(at_ckbsy());                /* check busy bit in controler */
  50.    while(at_ckbsy());                /* check busy bit in controler */
  51.  
  52.    if (at_rstat() & 0x05)               /* check if error for recal */
  53.       show_error();                /* show any errors */
  54.  
  55. }                        /* end of init_disk */
  56.  
  57.  
  58.  
  59. /*************************************/
  60. /*                     */
  61. /* should_do_errors()             */
  62. /*                     */
  63. /* find out from user if bad tracks  */
  64. /* should be marked bad then mark    */
  65. /* bad if was "Y" typed.             */
  66. /*                     */
  67. /*************************************/
  68. should_do_errors()
  69.  
  70. {                        /* start of error junk */
  71.    int done;
  72.    unsigned char resp;
  73.    char temp_str[8];
  74.  
  75.  
  76.    do_errors();                /* show errors found in err_table */
  77.    printf("\n\nDo you wish to mark these blocks bad? (y/n)");
  78.    done = FALSE;
  79.    while(!done)
  80.    {
  81.       resp = get_input(redirection);               /* get user responce */
  82.       resp = toupper(resp);
  83.       switch(resp)
  84.       {                     /* start of switch */
  85.      case 'Y' : done = TRUE;
  86.             mark_bad_track();          /* mark bad tracks */
  87.             break;
  88.      case 'N' : err_count = 1;
  89.             done = TRUE;
  90.             break;
  91.      default  : BELL;
  92.       }                     /* end of switch */
  93.     }                        /* end while */
  94.  }                        /* end of sould_do_errors */
  95.  
  96.  
  97.  
  98.  
  99. /*************************************/
  100. /*                     */
  101. /* enter_bad_map()             */
  102. /*                     */
  103. /* user can enter bad track map from */
  104. /* keyboard.                 */
  105. /*                     */
  106. /*************************************/
  107. enter_bad_map()
  108.  
  109. {                        /* start of enter_bad_map() */
  110.    int done,in_valid;
  111.    unsigned char temp_str[8];
  112.    int temp1,temp2,temp3;
  113.  
  114.    cls();
  115.    curs(1,1);
  116.    printf("\n\nYou may now enter additional blocks to be marked bad.");
  117.    printf("\n\nEnter cylinder number <CR> and head number <CR>) at ");
  118.    printf("\nthe prompt. To end entry, press ESC. at the prompt\n");
  119.    curs(8,20);printf("Enter  <cylinder#> <head#>: ");
  120.  
  121.    done = FALSE;
  122.    while(!done)
  123.    {                        /* start of while */
  124.       do_ilt(128,0,wr_buffer);            /* set bad sector mark */
  125.       in_valid = TRUE;
  126.       while((!done) AND in_valid)
  127.       {
  128.      upscroll(1,10,14,5,78,VNORMAL);    /* scroll up one line */
  129.      done = get_dec2(14,31,4,&hd_table.cyl_number,ESC); /* get cyl number */
  130.      if((0 <= hd_table.cyl_number)
  131.         AND (hd_table.cyl_number <= hd_table.max_cyl))
  132.         in_valid = FALSE;
  133.      if((!done) AND in_valid) BELL;
  134.       }
  135.  
  136.       if(!done)
  137.       {                     /* start of if done */
  138.      in_valid = TRUE;
  139.      while((!done) AND in_valid)
  140.      {                    /* start of if valid */
  141.         done = get_dec2(14,42,2,&hd_table.head_number,ESC); /* get head number */
  142.         if((0 <= hd_table.head_number)
  143.            AND (hd_table.head_number <= hd_table.max_head))
  144.            in_valid = FALSE;
  145.         if((!done) AND in_valid) BELL;
  146.      }                    /* end while valid */
  147.       }                     /* end if done */
  148.       if(!done)
  149.       {                     /* start of if done */
  150.      do_ilt(128,hd_table.head_number,wr_buffer);   /* set badsector mark */
  151.      load_task_file();            /* load task file */
  152.      at_fmt();                /* do format */
  153.      while(!( 0x08 & at_rstat()));        /* wait for data request */
  154.      at_wrbfr(0, wr_buffer);        /* write buffer */
  155.      while(at_ckbsy());            /* check busy bit in controler */
  156.      while(at_ckbsy());            /* check busy bit in controler */
  157.       }                     /* end if done */
  158.    }                        /* end of while */
  159. }                        /* end enter_bad_map() */
  160.  
  161.  
  162.  
  163.  
  164. /*************************************/
  165. /*                     */
  166. /* mark bad track             */
  167. /*                     */
  168. /*************************************/
  169. mark_bad_track()
  170.  
  171.  
  172. {                       /* start of mark_bad_track */
  173.     bad_count = 0;
  174.     do_ilt(128,0,wr_buffer);
  175.     for (errcnt = 1; errcnt < err_count; errcnt++)
  176.     {
  177.         hd_table.cyl_number = err_table[errcnt].cyl;
  178.         hd_table.head_number = err_table[errcnt].head;
  179.         load_task_file();
  180.         at_fmt();
  181.         while(!( 0x08 & at_rstat())); /* wait for data request */
  182.         at_wrbfr(0, wr_buffer);
  183.         while(at_ckbsy());        /* check busy bit in controler */
  184.         while(at_ckbsy());        /* check busy bit in controler */
  185.         bad_count++;
  186.     }
  187. }                        /* end of mark_bad_sector */
  188. /*************************************/
  189.  
  190.  
  191.  
  192.  
  193.  
  194. /*************************************/
  195. /*                     */
  196. /* make block mark and sector #      */
  197. /* for one track             */
  198. /*                     */
  199. /*************************************/
  200.  
  201. do_ilt(block_mark,head,buff)
  202.  
  203. char block_mark;
  204. int  head;
  205. unsigned char  *buff;
  206.  
  207. {
  208.  
  209.    int offset, count, ileave, maxcnt;
  210.    unsigned char temp, *p;
  211.  
  212.    p = buff;
  213.    for( count=0; count < 512; count++ )
  214.       *p++ = 0xff;                /* fill buffer with 0xFF */
  215.    ileave = hd_table.ileave;            /* set up vars for loop */
  216.    count = 0;
  217.    if(hd_table.alt_sector) maxcnt = hd_table.max_sec-1;
  218.    else maxcnt = hd_table.max_sec;
  219.    offset = (hd_table.skew*head)%maxcnt;    /* clear offset */
  220.  
  221.    while ( count < maxcnt )
  222.    {
  223.       for( ; *(buff+(offset*2)) != 0xFF; offset++); /* inc offset if overlap*/
  224.       p = buff + ( offset * 2 );
  225.       *p++ = block_mark;                    /* block mark */
  226.       *p = 1+(count % maxcnt);       /* sector number */
  227.       offset += ileave;             /* inc offset by interleave */
  228.       offset = offset % maxcnt;         /* loop offset */
  229.       count++;
  230.    }                        /* end of while */
  231.    if(hd_table.alt_sector)            /* if need alt sector */
  232.    {
  233.       p = buff + (maxcnt * 2);
  234.       *p++ = block_mark;            /* block mark */
  235.       *p = alt_value;                /* sector number*/
  236.     }
  237. }
  238.  
  239. /*************************************/
  240. /*                     */
  241. /* set up task file and load it      */
  242. /*                     */
  243. /*************************************/
  244.  
  245. load_task_file()
  246.  
  247. {
  248.  
  249.     task_file.error  = hd_table.precomp;
  250.     task_file.secnt  = hd_table.blk_size;
  251.     task_file.sector = hd_table.sec_number;
  252.     task_file.cyllo  = (hd_table.cyl_number % 256);
  253.     task_file.cylhi  = (hd_table.cyl_number / 256);
  254.     task_file.SDH     = (hd_table.head_number & 0xf) +     /* bits 0-3 */
  255.                ((hd_table.drv_number <<4) & 0x10) +  /* bit  4 */
  256.                ((hd_table.sec_size << 5) & 0x60) +     /* bits 5,6 */
  257.                (hd_table.ecc << 7);          /* bit 7 */
  258.     at_wtskf(&task_file);
  259. }
  260.  
  261. /*************************************/
  262. /*                     */
  263. /* display errors from reisters      */
  264. /*                     */
  265. /*************************************/
  266.  
  267. show_error()
  268.  
  269. {
  270.     curs(22,1);
  271.     printf("   Error!!... Cyl. %4d   Head %2d  Status  %2x  Error  %2x",
  272.         hd_table.cyl_number, hd_table.head_number,
  273.         at_rstat(), at_rderr());
  274. }
  275.  
  276. /*************************************/
  277. /*                     */
  278. /* display errors found in error table*/
  279. /*                     */
  280. /*************************************/
  281.  
  282. do_errors()
  283. {
  284.     cls();
  285.     curs(1,1);
  286.     printf("Errors will be marked at the following cylinder/head locations:");
  287.     printf("\n\n");
  288.     for (errcnt = 1; errcnt < err_count; errcnt++)
  289.     {
  290.         printf("        %4d/%2d", err_table[errcnt].cyl,
  291.             err_table[errcnt].head);
  292.         if ((errcnt % 5) == 0)
  293.             printf ("\n");
  294.     }
  295. }
  296.  
  297. /*************************************/
  298. /*                     */
  299. /* dimp 5 lines of buffer to screen  */
  300. /*                     */
  301. /*************************************/
  302.  
  303. dump_5lines(buffer)
  304.  
  305. char *buffer;
  306.  
  307. {
  308.     int num_bytes, count;
  309.  
  310.     for (count = 0; count < 80; count++)
  311.     {
  312.         if ((count % 16) == 0)
  313.             printf("\n%04x    ", count);
  314.         printf("%02x  ", buffer[count]);
  315.     };
  316.     printf("\n");
  317. }
  318.