home *** CD-ROM | disk | FTP | other *** search
/ Falcon 030 Power 2 / F030_POWER2.iso / ST_STE / MAGS / TOXIC_14.ARJ / toxic_14 / TOXIC_14.D_2 / LEONARD / LEO_ST.ZIP / ST_PC / HD_EMUL / HARDDISK.C < prev    next >
C/C++ Source or Header  |  1995-06-28  |  7KB  |  557 lines
  1.  
  2.  
  3.  
  4. // includes.
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <stddef.h>
  8. #include <conio.h>
  9. #include <time.h>
  10.  
  11. typedef    unsigned long    UD;
  12. typedef    long        SD;
  13. typedef unsigned short    UW;
  14. typedef short        SW;
  15. typedef unsigned char    UB;
  16. typedef char        SB;
  17.  
  18.  
  19.  
  20. #define HEADER_SIZE        8
  21.  
  22. #define    CMD_HARD_INIT        0
  23. #define    CMD_READ_SECTOR        1
  24. #define CMD_WRITE_SECTOR    2
  25. #define CMD_DODISK        3
  26. #define CMD_SHUTDOWN        4
  27.  
  28.  
  29. #define TIMING        256
  30.  
  31.  
  32.  
  33.  
  34. #define     UCHAR_MAX    (255)
  35. #define        CHAR_BIT    (8)
  36. #define        CRCPOLY        0xEDB88320L
  37. #define        UPDATE_CRC(r,c) r=crctable[ ((UB)(r)^(UB)(c))&0xff ]^(r>>CHAR_BIT)
  38. typedef        unsigned long    UCRC;
  39.  
  40. static UCRC   crctable[UCHAR_MAX + 1];
  41.  
  42.  
  43. UD    calc_crc(char *ptr,UD size);
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50. UB    command_buffer[8];
  51. char    bcrc32[4];
  52. UD    vcrc32,ccrc;
  53.  
  54. static    char    *ret_ok="LEO!";
  55. static    char    *ret_false="AAAA";
  56. static    UB    tampon[512*10];
  57.  
  58.  
  59.  
  60. UD    get_dword(char *pt)
  61.  {
  62.  UD    ret;
  63.  
  64.  
  65.     ret=*pt++;
  66.     ret|=(*pt++)<<8;
  67.     ret|=(*pt++)<<16;
  68.     ret|=(*pt++)<<24;
  69.     return ret;
  70.  
  71.  }
  72.  
  73. void    bell(void)
  74.  {
  75.     putchar(7);
  76.  }
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83. int    receive_block(UB *ptr,int size)
  84.  {
  85.  register UB    data,o;
  86.  UB *optr;
  87.  int    osize;
  88.  
  89.  
  90.     optr=ptr;
  91.     osize=size;
  92.  
  93.  
  94.  
  95.     do {
  96.  
  97.       do {
  98.         data=inp(0x379);
  99.       } while (data&0x80);
  100.  
  101.  
  102.       o=(data&0x78)<<1;
  103.  
  104.       do {
  105.         data=inp(0x379);
  106.       } while (!(data&0x80));
  107.  
  108.  
  109.       o |= ((data&0x78)>>3);
  110.  
  111.       *ptr++=o;
  112.  
  113.     } while (--size);
  114.  
  115.  
  116.  
  117.     // reception du CRC32
  118.  
  119.     ptr=bcrc32+4;
  120.  
  121.     size=4;
  122.     do {
  123.  
  124.       do {
  125.         data=inp(0x379);
  126.       } while (data&0x80);
  127.  
  128.  
  129.       o=(data&0x78)<<1;
  130.  
  131.       do {
  132.         data=inp(0x379);
  133.       } while (!(data&0x80));
  134.  
  135.  
  136.       o |= ((data&0x78)>>3);
  137.  
  138.       *(--ptr)=o;
  139.  
  140.     } while (--size);
  141.  
  142.  
  143.     //vcrc32=get_dword(bcrc32);
  144.  
  145.  
  146.     vcrc32=*((UD *)bcrc32);
  147.     ccrc=calc_crc(optr,osize);
  148.  
  149.  
  150.     if (vcrc32==ccrc) return 0;
  151.  
  152.  
  153.     return (-1);
  154.  
  155.  }
  156.  
  157.  
  158. void    mwait(UD v)
  159.  {
  160.  
  161.     v<<=2;
  162.  
  163.     do {
  164.     } while (--v);
  165.  
  166.  }
  167.  
  168.  
  169. void    send_block(UB *ptr,int size)
  170.  {
  171.  register UB    data,strobe;
  172.  
  173.  
  174.  
  175.  
  176.  
  177.     ccrc=calc_crc(ptr,(UD)size);
  178.  
  179.  
  180. #if 0
  181.     mwait(32767);
  182.     mwait(32767);
  183.     mwait(32767);
  184.     mwait(32767);
  185.     mwait(32767);
  186.     mwait(32767);
  187.     mwait(32767);
  188. #endif
  189.     mwait(32767);
  190.  
  191.     do {
  192.  
  193.       data=*ptr++;
  194.       outp(0x378,data);        // Ecrit data.
  195.       strobe=inp(0x37a);
  196.       strobe^=1;
  197.       outp(0x37a,strobe);        // Ecrit data.
  198.       mwait(TIMING);
  199.  
  200.     } while (--size);
  201.  
  202.  
  203.     size=4;
  204.     do {
  205.  
  206.       data=(ccrc>>24);
  207.       ccrc<<=8;
  208.  
  209.       outp(0x378,data);        // Ecrit data.
  210.       strobe=inp(0x37a);
  211.       strobe^=1;
  212.       outp(0x37a,strobe);        // Ecrit data.
  213.       mwait(TIMING);
  214.  
  215.     } while (--size);
  216.  
  217.  
  218.  }
  219.  
  220.  
  221.  
  222.  
  223. int    wait_cmd(void)
  224.  {
  225.  int    cmd;
  226.  
  227.  
  228.  
  229.     printf("Waiting command from ATARI...\n");
  230.  
  231.  
  232.     receive_block(command_buffer,HEADER_SIZE);
  233.  
  234.     cmd=command_buffer[0]<<8 | command_buffer[1];
  235.  
  236.  
  237.     return cmd;
  238.  
  239.  
  240.  }
  241.  
  242.  
  243. void    make_crctable(void)
  244.  {
  245.  UD    i, j;
  246.  UCRC    r;
  247.  
  248.  
  249.     for (i = 0; i <= UCHAR_MAX; i++) {
  250.       r = i;
  251.       for (j=CHAR_BIT;j>0;j--) {
  252.         if (r & 1)
  253.           r=(r>>1)^CRCPOLY;
  254.         else
  255.           r>>=1;
  256.       }
  257.       crctable[i]=r;
  258.     }
  259.  }
  260.  
  261.  
  262. UD    calc_crc(char *ptr,UD size)
  263.  {
  264.  UD    crc;
  265.  
  266.  
  267.     crc=0;
  268.  
  269.     while (size--) UPDATE_CRC(crc,*ptr++);
  270.  
  271.     return (crc);
  272.  }
  273.  
  274.  
  275. void    p_cmd(char *message)
  276.  {
  277.  
  278.  
  279.     printf("COMMAND:%s\n",message);
  280.  }
  281.  
  282.  
  283. void    test(void)
  284.  {
  285.  UB    data;
  286.  
  287.  
  288.     do {
  289.       data=inp(0x379);
  290.  
  291.       data&=0x78;
  292.       data>>=3;
  293.  
  294.       printf("DATA=$%02X\n",data);
  295.  
  296.     } while (!kbhit());
  297.  
  298.     while (kbhit()) getch();
  299.  
  300.  
  301.  }
  302.  
  303.  
  304.  
  305.  
  306. void    test_send(void)
  307.  {
  308.  FILE    *in;
  309.  UW    i;
  310.  
  311.  
  312.     in=fopen("harddisk.exe","rb");
  313.     if (!in) {
  314.         printf("error\n");
  315.         exit(1);
  316.     }
  317.  
  318.     fread(tampon,1,4*1024,in);
  319.     fclose(in);
  320.  
  321.     //memset(tampon,0xaa,4*1024);
  322.  
  323.  
  324.     for (i=0;i<(4*1024);i+=4) {
  325.       tampon[i]=0;
  326.       tampon[i+1]=0x34;
  327.       tampon[i+2]=0x56;
  328.       tampon[i+3]=0x78;
  329.     }
  330.  
  331.  
  332.  
  333.     for (i=0;i<8;i++) {
  334.       send_block(tampon,4*1024);
  335.       printf("%d\n",i);
  336.     }
  337.  
  338.  
  339.     exit(1);
  340.  
  341.  }
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.  
  349.  
  350.  
  351. void    main(void)
  352.  {
  353.  int    cmd;
  354.  FILE    *out;
  355.  UD    offset,nb;
  356.  FILE    *hard_disk;
  357.  UB    *buffer;
  358.  UW    ret;
  359.  
  360.  
  361.  
  362.     make_crctable();
  363.     outp(0x37a,0);        // strobe a zero.
  364.  
  365.  
  366. //    test_send();
  367.  
  368.     #if 0
  369.     out=fopen("disk.bin","wb");
  370.     if (!out) {
  371.       printf("Merde.\n");
  372.       exit(1);
  373.     }
  374.     #endif
  375.  
  376.     //hard_disk=fopen("disk.emu","rb");
  377.     hard_disk=fopen("disk.emu","rb+wb");
  378.     if (!hard_disk) {
  379.       printf("Blairo\n");
  380.       exit(1);
  381.     }
  382.  
  383.  
  384.  
  385.     printf(    "ATARI-ST hard-disk simulator.\n"
  386.         "Code,Hardware and Idea by Leonard/OXYGENE.\n\n"
  387.         "Serveur waiting...\n\n");
  388.  
  389.  
  390.  
  391.  
  392.  
  393.     for (;;) {
  394.  
  395.  
  396.       cmd=wait_cmd();
  397.  
  398.       if (cmd==CMD_SHUTDOWN) {
  399.         p_cmd("SHUTDOWN !!");
  400.         break;
  401.       }
  402.  
  403.  
  404.       switch (cmd) {
  405.       case CMD_HARD_INIT:
  406.         p_cmd("Hard-Disk emulator initializing");
  407.  
  408.  
  409.         send_block(ret_ok,4);
  410.  
  411.  
  412.         break;
  413.  
  414.  
  415.       case CMD_DODISK:
  416.         p_cmd("Receiving sector.");
  417.  
  418.  
  419.         send_block(ret_ok,4);
  420.  
  421.         printf("return ok sended.\n");
  422.  
  423.         if (receive_block(tampon,512*9)) {
  424.           printf("Erreur reception.\n");
  425.           exit(1);
  426.         }
  427.  
  428.         fwrite(tampon,1,512*9,out);
  429.  
  430.         printf("tampon written\n");
  431.  
  432.         send_block(ret_ok,4);
  433.  
  434.  
  435.         break;
  436.  
  437.  
  438.  
  439.       case CMD_READ_SECTOR:
  440.  
  441.  
  442.         p_cmd("READ SECTOR.");
  443.         send_block(ret_ok,4);
  444.  
  445.  
  446.         offset= command_buffer[2]<<24;
  447.         offset|=command_buffer[3]<<16;
  448.         offset|=command_buffer[4]<<8;
  449.         offset|=command_buffer[5];
  450.  
  451.         nb  = command_buffer[6]<<8;
  452.         nb |= command_buffer[7];
  453.  
  454.  
  455.         printf("Sector:%ld Nb:%ld\n",(offset/512),nb);
  456.  
  457.  
  458.         nb*=512;
  459.  
  460.  
  461.         buffer=(UB *)malloc(nb);
  462.         if (!buffer) {
  463.           printf("MALLOC error.\n");
  464.           exit(1);
  465.         }
  466.  
  467.         fseek(hard_disk,offset,SEEK_SET);
  468.         fread(buffer,1,nb,hard_disk);
  469.  
  470.         send_block(buffer,nb);
  471.  
  472.         free(buffer);
  473.  
  474.  
  475.         break;
  476.  
  477.  
  478.       case CMD_WRITE_SECTOR:
  479.  
  480.  
  481.         p_cmd("WRITE SECTOR.");
  482.         send_block(ret_ok,4);
  483.  
  484.  
  485.         offset= command_buffer[2]<<24;
  486.         offset|=command_buffer[3]<<16;
  487.         offset|=command_buffer[4]<<8;
  488.         offset|=command_buffer[5];
  489.  
  490.         nb  = command_buffer[6]<<8;
  491.         nb |= command_buffer[7];
  492.  
  493.  
  494.         printf("Sector:%ld Nb:%ld\n",(offset/512),nb);
  495.  
  496.  
  497.         nb*=512;
  498.  
  499.  
  500.         buffer=(UB *)malloc(nb);
  501.         if (!buffer) {
  502.           printf("MALLOC error.\n");
  503.           exit(1);
  504.         }
  505.  
  506.  
  507.         ret=receive_block(buffer,nb);
  508.  
  509.         mwait(65536);
  510.  
  511.         if (ret)
  512.           send_block(ret_false,4);
  513.         else {
  514.           fseek(hard_disk,offset,SEEK_SET);
  515.           if (fwrite(buffer,1,nb,hard_disk)!=nb) {
  516.         printf("PC WRITING ERROR !!%c\n",7);
  517.         send_block(ret_false,4);
  518.           } else {
  519.             send_block(ret_ok,4);
  520.           }
  521.         }
  522.  
  523.         free(buffer);
  524.  
  525.  
  526.  
  527.         break;
  528.  
  529.  
  530.  
  531.  
  532.       default:
  533.         printf("%cERROR:Unknow command !!\n",7);
  534.         printf("Cmd received:$%04X\n",cmd);
  535.         exit(1);
  536.         break;
  537.  
  538.  
  539.  
  540.       }
  541.  
  542.  
  543.  
  544.     }
  545.  
  546.  
  547.  
  548.     printf("\nSystem halted.\n");
  549.  
  550.  
  551.     fclose(out);
  552.  
  553.  
  554.  }
  555.  
  556.  
  557.