home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_oth / xprd687.lha / src / initio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-27  |  8.5 KB  |  383 lines
  1. /*
  2.  
  3.     IO.c
  4.     ----
  5.     Definitions for XPR_IO-functions
  6.  
  7.     (C) 1990 Oliver Wagner, All Rights Reserved
  8.  
  9. */
  10.  
  11. #include <proto/exec.h>
  12. #include <proto/dos.h>
  13. #include <devices/serial.h>
  14. #include <devices/timer.h>
  15. #include <string.h>
  16.  
  17. #define print(s) Write(Output(),s,strlen(s))
  18.  
  19. #include "xproto.h"
  20.  
  21. void plog(char,char*,...);
  22.  
  23. /* external Intuition functions */
  24. extern int xpr_opendisplay(void);
  25. extern int xpr_closedisplay(void);
  26. extern int xpr_displayupdate(struct XPR_IO*);
  27. extern int xpr_chk4abort(void);
  28. extern long xpr_windowsig;
  29.  
  30. /* Global IO-Request for XPR */
  31. extern struct IOExtSer *xpr_serio;
  32.  
  33. /* external filename array */
  34. extern char *xprfilearray[];
  35.  
  36. /* static Data */
  37. static struct timerequest treq;
  38. static struct MsgPort *tport;
  39. static char timeropen;
  40.  
  41. extern short nowindow;
  42.  
  43. /* The timer functions */
  44. static long opentimer(void)
  45. {
  46.     tport=CreatePort(0,0);
  47.     if(!tport) return(-1);
  48.     treq.tr_node.io_Message.mn_ReplyPort=tport;
  49.     if(OpenDevice("timer.device",UNIT_VBLANK,&treq,0)) return(-1);
  50.     timeropen=1;
  51.     return(0);
  52. }
  53. static void closetimer(void)
  54. {
  55.     if(timeropen) CloseDevice(&treq);
  56.     if(tport) DeletePort(tport);
  57. }
  58. static void qtimer(long micros)
  59. {
  60.     int secs=0;
  61.     if (micros > 1000000) {
  62.      secs    = micros / 1000000;
  63.      micros = micros % 1000000;
  64.     }
  65.     treq.tr_time.tv_micro=micros;
  66.     treq.tr_time.tv_secs=secs;
  67.     treq.tr_node.io_Command=TR_ADDREQUEST;
  68. /*    printf("QTIMER s=%ld m=%ld\n",secs,micros);*/
  69.     SendIO(&treq);
  70. }
  71.  
  72. /* the finfo-function */
  73. static long __saveds xpr_finfo(char *name,long type)
  74. {
  75.     struct FileInfoBlock *fib=AllocMem(sizeof(struct FileInfoBlock),0);
  76.     BPTR lck;
  77.     long result=0;
  78.  
  79.     plog('+',"FINFO: %s (%ld)\n",name,type);
  80.     if(!fib) return(0);
  81.     if(!(lck=Lock(name,SHARED_LOCK))) goto xit;
  82.     Examine(lck,fib);
  83.     UnLock(lck);
  84.     result=fib->fib_Size;
  85.     if(type==2) result=1;
  86.     else if(type!=1) result=0;
  87. xit:
  88.     FreeMem(fib,sizeof(struct FileInfoBlock));
  89. /*    printf("result=%ld\n",result);*/
  90.     return(result);
  91. }
  92.  
  93. /* the serwrite function */
  94. static long __saveds xpr_swrite(char *buffer,long size)
  95. {
  96. /*    printf("SWRITE: buffer=%lx size=%ld\n",buffer,size);*/
  97.     xpr_serio->IOSer.io_Length=size;
  98.     xpr_serio->IOSer.io_Data=buffer;
  99.     xpr_serio->IOSer.io_Command=CMD_WRITE;
  100.     DoIO(xpr_serio);
  101.     return((long)xpr_serio->IOSer.io_Error);
  102. }
  103.  
  104. long chk4cd(void)
  105. {
  106.     xpr_serio->IOSer.io_Command=SDCMD_QUERY;
  107.     DoIO(xpr_serio);
  108.     return(!(xpr_serio->io_Status&(1<<5)));
  109. }
  110.  
  111. /* the serread function */
  112. static long __saveds xpr_sread(char *buffer,long size,long timeout)
  113. {
  114.     long flag=xpr_windowsig|(1<<xpr_serio->IOSer.io_Message.mn_ReplyPort->mp_SigBit);
  115.     long len,nflag;
  116.  
  117.     /*printf("SREAD() buffer=%lx size=%ld timeout=%ld\n",buffer,size,timeout);*/
  118.     SetSignal(0,flag);
  119.     if(timeout) {
  120.     flag|=1<<tport->mp_SigBit;
  121.     /*printf("Starting timer...\n");*/
  122.     qtimer(timeout);
  123.     }
  124.     else {
  125.     xpr_serio->IOSer.io_Command=SDCMD_QUERY;
  126.     DoIO(xpr_serio);
  127.     if(!(len=xpr_serio->IOSer.io_Actual)) return(0);
  128.     else {
  129.         if(len>size) len=size;
  130.         xpr_serio->IOSer.io_Command=CMD_READ;
  131.         xpr_serio->IOSer.io_Data=buffer;
  132.         xpr_serio->IOSer.io_Length=len;
  133.         DoIO(xpr_serio);
  134.         /*printf("Fastread return %ld\n",xpr_serio->IOSer.io_Actual);*/
  135.         return((long)xpr_serio->IOSer.io_Actual);
  136.     }
  137.     }
  138.     SetSignal(0,flag);
  139.     xpr_serio->IOSer.io_Command=CMD_READ;
  140.     xpr_serio->IOSer.io_Data=buffer;
  141.     xpr_serio->IOSer.io_Length=size;
  142.     SendIO(xpr_serio);
  143.     nflag=Wait(flag);
  144.     if(nflag&xpr_windowsig) {
  145.     AbortIO(&treq);
  146.     AbortIO(xpr_serio);
  147.     WaitIO(&treq);
  148.     WaitIO(xpr_serio);
  149.     return(-1);
  150.     }
  151.     if(nflag&(1<<xpr_serio->IOSer.io_Message.mn_ReplyPort->mp_SigBit)) {
  152.     AbortIO(&treq);
  153.     WaitIO(xpr_serio);
  154.     WaitIO(&treq);
  155.     /*printf("Normal read returns %ld (error %ld)\n",xpr_serio->IOSer.io_Actual,(long)xpr_serio->IOSer.io_Error);*/
  156.     return((long)xpr_serio->IOSer.io_Actual);
  157.     }
  158.     /*printf("TIMEOUT:\n");*/
  159.     AbortIO(xpr_serio);
  160.     WaitIO(&treq);
  161.     WaitIO(xpr_serio);
  162.     return((long)xpr_serio->IOSer.io_Actual);
  163. }
  164.  
  165. /* sflush - flushes serial port */
  166. static long __saveds xpr_sflush(void)
  167. {
  168.     xpr_serio->IOSer.io_Command=CMD_FLUSH;
  169.     DoIO(xpr_serio);
  170.     return((long)xpr_serio->IOSer.io_Error);
  171. }
  172.  
  173. /* setserial; stolen from TERM by Olsen */
  174. #define ST_PARTYON    (1 << 0)
  175. #define ST_PARTYODD    (1 << 1)
  176. #define ST_7WIRE    (1 << 2)
  177. #define ST_QBREAK    (1 << 3)
  178. #define ST_RADBOOGIE    (1 << 4)
  179. #define ST_SHARED    (1 << 5)
  180. #define ST_EOFMODE    (1 << 6)
  181. #define ST_XDISABLED    (1 << 7)
  182. #define ST_PARTYMARKON    (1 << 8)
  183. #define ST_PARTYMARK    (1 << 9)
  184. #define ST_2BITS    (1 << 10)
  185. #define ST_READ7    (1 << 11)
  186. #define ST_WRITE7    (1 << 12)
  187. static long __saveds xpr_setserial(long Status)
  188. {
  189.     STATIC LONG XprBauds[12] =
  190.     {
  191.         110,
  192.         300,
  193.         1200,
  194.         2400,
  195.         4800,
  196.         9600,
  197.         19200,
  198.         31250,
  199.         38400,
  200.         57600,
  201.         76800,
  202.         115200
  203.     };
  204.  
  205.     LONG Return,i;
  206.  
  207.     xpr_serio -> IOSer . io_Command = SDCMD_QUERY;
  208.     DoIO(xpr_serio);
  209.  
  210.     Return = xpr_serio -> io_SerFlags & 0xFF;
  211.  
  212.     if(xpr_serio -> io_ExtFlags & SEXTF_MSPON)
  213.         Return |= ST_PARTYMARKON;
  214.  
  215.     if(xpr_serio -> io_ExtFlags & SEXTF_MARK)
  216.         Return |= ST_PARTYMARK;
  217.  
  218.     if(xpr_serio -> io_StopBits == 2)
  219.         Return |= ST_2BITS;
  220.  
  221.     if(xpr_serio -> io_ReadLen == 7)
  222.         Return |= ST_READ7;
  223.  
  224.     if(xpr_serio -> io_WriteLen == 7)
  225.         Return |= ST_WRITE7;
  226.  
  227.     for(i = 0 ; i < 12 ; i++)
  228.     {
  229.         if(xpr_serio -> io_Baud == XprBauds[i])
  230.         {
  231.             Return |= (i << 16);
  232.  
  233.             break;
  234.         }
  235.     }
  236.  
  237.     if(Status != -1)
  238.     {
  239.         xpr_serio -> IOSer . io_Command    = SDCMD_SETPARAMS;
  240.  
  241.         xpr_serio -> io_SerFlags        = Status & 0xFF;
  242.         xpr_serio -> io_ExtFlags        = 0;
  243.  
  244.         if(Status & ST_PARTYMARKON)
  245.             xpr_serio -> io_ExtFlags |= SEXTF_MSPON;
  246.  
  247.         if(Status & ST_PARTYMARK)
  248.             xpr_serio -> io_ExtFlags |= SEXTF_MARK;
  249.  
  250.         if(Status & ST_2BITS)
  251.             xpr_serio -> io_StopBits = 2;
  252.         else
  253.             xpr_serio -> io_StopBits = 1;
  254.  
  255.         if(Status & ST_READ7)
  256.             xpr_serio -> io_ReadLen = 7;
  257.         else
  258.             xpr_serio -> io_ReadLen = 8;
  259.  
  260.         if(Status & ST_WRITE7)
  261.             xpr_serio -> io_WriteLen = 7;
  262.         else
  263.             xpr_serio -> io_WriteLen = 8;
  264.  
  265.         DoIO(xpr_serio);
  266.  
  267.     }
  268.  
  269.     return(Return);
  270.  
  271. }
  272. /* EOT [end of theft] */
  273.  
  274.  
  275. /* The ffirst() and ffnext() functions */
  276. static long __saveds xpr_ffirst(char *buffer,char *pattern)
  277. {
  278.     strcpy(buffer,xprfilearray[0]);
  279.     plog('+',"FFIRST: returning %s\n",buffer);
  280.     return(1);
  281. }
  282. static long __saveds xpr_fnext(long oc,char *buffer,char *pattern)
  283. {
  284.     if(!xprfilearray[oc]) {
  285.     plog('+',"FNEXT: end of array\n");
  286.     return(0);
  287.     }
  288.     else {
  289.     strcpy(buffer,xprfilearray[oc++]);
  290.     plog('+',"FNEXT: returning %s\n",buffer);
  291.     return(oc);
  292.     }
  293. }
  294.  
  295. static long __saveds xpr_gets(char*b,char*p)
  296. {
  297. /*    print("GETS: ");print(b);print(" - ");print(p);print("\n");*/
  298.     return(0);
  299. }
  300.  
  301. /* the stub routines for a4 loading :-( */
  302. static long __saveds xpr_fopen(char*a1,char*a2)
  303. {
  304.     long h;
  305.  
  306.     plog('+',"FOPEN: %s,'%s'\n",a1,a2);
  307.     switch(*a2) {
  308.     case 'r': return(Open(a1,MODE_OLDFILE));
  309.     case 'w': return(Open(a1,MODE_NEWFILE));
  310.     case 'a': if(h=Open(a1,MODE_OLDFILE)) {
  311.             Seek(h,0,OFFSET_END);
  312.             return(h);
  313.           }
  314.           return(Open(a1,MODE_NEWFILE));
  315.     }
  316.     return(0);
  317. }
  318. static long __saveds xpr_fclose(long *a1)
  319. {
  320.     if(a1) Close(a1);
  321.     return(0);
  322. }
  323. static long __saveds xpr_fread(char*a1,long a2,long a3,long*fpt)
  324. {
  325. /*    printf("fread(%lx,%ld,%ld,%lx)\n",a1,a2,a3,fpt);*/
  326.     if(!a2) return(0);
  327.     return(Read(fpt,a1,a2*a3));
  328. }
  329. static long __saveds xpr_fwrite(char*a1,long a2,long a3,long*fpt)
  330. {
  331. /*    printf("fwrite(%lx,%ld,%ld,%lx)\n",a1,a2,a3,fpt);*/
  332.     if(!a2) return(0);
  333.     return(Write(fpt,a1,a2*a3));
  334. }
  335. static long __saveds xpr_fseek(long*a1,long a2,long a3)
  336. {
  337.     long h=-1;
  338. /*    printf("fseek(%lx,%ld,%ld)\n",a1,a2,a3);*/
  339.  
  340.     switch(a3) {
  341.     case 0: h=OFFSET_BEGINNING; break;
  342.     case 1: h=OFFSET_CURRENT; break;
  343.     case 2: h=OFFSET_END; break;
  344.     default: return(-1);
  345.     }
  346.     return((Seek(a1,a2,h)!=-1)?0:-1);
  347. }
  348. static long __saveds xpr_unlink(char*a1)
  349. {
  350.     plog('+',"UNLINK: %s\n",a1);
  351.     return(DeleteFile(a1));
  352. }
  353.  
  354. /* init the xprIO and build everything */
  355. long init_xpr(struct XPR_IO *IO)
  356. {
  357.    IO->xpr_fopen     = xpr_fopen;
  358.    IO->xpr_fclose    = xpr_fclose;
  359.    IO->xpr_fread     = xpr_fread;
  360.    IO->xpr_fwrite    = xpr_fwrite;
  361.    IO->xpr_sread     = xpr_sread;
  362.    IO->xpr_swrite    = xpr_swrite;
  363.    IO->xpr_sflush    = xpr_sflush;
  364.    IO->xpr_update    = xpr_displayupdate;
  365.    IO->xpr_chkabort  = xpr_chk4abort;
  366.    IO->xpr_setserial = xpr_setserial;
  367.    IO->xpr_ffirst    = xpr_ffirst;
  368.    IO->xpr_fnext     = xpr_fnext;
  369.    IO->xpr_finfo     = xpr_finfo;
  370.    IO->xpr_fseek     = xpr_fseek;
  371.    IO->xpr_gets      = xpr_gets;
  372.    IO->xpr_unlink    = xpr_unlink;
  373. /*   xpr_sflush();*/
  374.    if(xpr_opendisplay()) return(-1);
  375.    return(opentimer());
  376. }
  377.  
  378. void close_xpr(void)
  379. {
  380.     xpr_closedisplay();
  381.     closetimer();
  382. }
  383.