home *** CD-ROM | disk | FTP | other *** search
/ Transactor / Transactor_26_1988_Transactor_Publishing.d64 / dos.c < prev    next >
Text File  |  2023-02-26  |  5KB  |  309 lines
  1. /* dos.c - operating system stuff:
  2.   disk support
  3.   serial i/o
  4.   kb i/o
  5.   timers */
  6. /* W Mat Waites - Sept 1988 */
  7.  
  8. #include <stdio.h>
  9.  
  10. /* 5-9 may be used with "basic" open */
  11. #define KB 5
  12. #define RS 6
  13.  
  14. /* kludge for reliable 1200 baud */
  15. #define KLUDGE 40
  16.  
  17. /* kernel routines */
  18. #define CHKIN  0xffc6
  19. #define GETIN  0xffe4
  20. #define TKSA   0xff96
  21. #define ACPTR  0xffa5
  22. #define TALK   0xffb4
  23. #define UNTLK  0xffab
  24.  
  25. /* input and output serial buffers */
  26. static char inbuf[256], otbuf[256];
  27.  
  28. /* serial interface functions */
  29.  
  30. /* openserial() - open serial port */
  31. openserial()
  32. {SHIFT-+}
  33.   short *ribuf = 0x00f7;
  34.   short *robuf = 0x00f9;
  35.  
  36.   /* open serial port */
  37.   open(RS, 2, 0, "");
  38.  
  39.   /* move pointers to buffers */
  40.   *ribuf = inbuf;
  41.   *robuf = otbuf;
  42. {SHIFT--}
  43.  
  44. /* closeserial() - close serial port */
  45. closeserial()
  46. {SHIFT-+}
  47.   close(RS);
  48. {SHIFT--}
  49.  
  50. /* 300, 450, 1200 implemented */
  51.  
  52. static short hibyte[3] = {SHIFT-+} 6,  4,  1{SHIFT--};
  53. static short lobyte[3] = {SHIFT-+}68, 12, 61{SHIFT--};
  54.  
  55. /* setserial() - set serial port */
  56. setserial(bd, bpc, sb, par)
  57. int bd, bpc, sb, par;
  58. {SHIFT-+}
  59.   short *m51ajb = 0x0295;
  60.   short *baudof = 0x0299;
  61.   char  *m51ctr = 0x0293;
  62.   char  *m51cdr = 0x0294;
  63.   char  *bitnum = 0x0298;
  64.   unsigned indx;
  65.  
  66.   switch(bd)
  67.     {SHIFT-+}
  68.     case 300:
  69.       indx = 0;
  70.       break;
  71.     case 450:
  72.       indx = 1;
  73.       break;
  74.     case 1200:
  75.       indx = 2;
  76.       break;
  77.     default:  /* default to 300 baud */
  78.       indx = 0;
  79.       break;
  80.     {SHIFT--}
  81.  
  82.   /* set baud rate */
  83.   *m51ajb = 256 * hibyte[indx] +
  84.     lobyte[indx];
  85.   *baudof = (*m51ajb)*2 + 200;
  86.  
  87.   /* stopbits */
  88.   if(sb < 1 {CBM-*}{CBM-*} sb > 2)
  89.     {SHIFT-+}
  90.     sb = 1;
  91.     {SHIFT--}
  92.   sb--;
  93.  
  94.   /* bits per char */
  95.   if(bpc < 5 {CBM-*}{CBM-*} bpc > 8)
  96.     {SHIFT-+}
  97.     bpc = 8;
  98.     {SHIFT--}
  99.   *bitnum = (char)(bpc + 1);
  100.   bpc = 8 - bpc;
  101.  
  102.   /* parity */
  103.   if(par < 0 {CBM-*}{CBM-*} par > 7)
  104.     {SHIFT-+}
  105.     par = 0;
  106.     {SHIFT--}
  107.  
  108.   /* put bpc, sb, and par in regs */
  109.   *m51ctr = (char)((bpc << 5)
  110.     {CBM-*} (sb << 7));
  111.   *m51cdr = (char)(par << 5);
  112. {SHIFT--}
  113.  
  114. /* getserial() - char from serial port */
  115. getserial()
  116. {SHIFT-+}
  117.   int ch;
  118.   char *rsstat = 0x0297;
  119.  
  120.   ch = getonechar(RS);
  121.  
  122.   /* check for empty buffer */
  123.   if((*rsstat & 0x08) == 0x08)
  124.     {SHIFT-+}
  125.     return -1;
  126.     {SHIFT--}
  127.   else
  128.     {SHIFT-+}
  129.     return ch;
  130.     {SHIFT--}
  131. {SHIFT--}
  132.  
  133. /* putserial() - char to serial port */
  134. putserial(ch)
  135. char ch;
  136. {SHIFT-+}
  137.   int i;
  138.  
  139.   putc(ch, RS);
  140.  
  141.   /* delay loop for 1200 baud kludge */
  142.   for(i=0; i<KLUDGE; i++)
  143.     {SHIFT-+}
  144.     {SHIFT--}
  145. {SHIFT--}
  146.  
  147.  
  148. /* keyboard interface functions */
  149.  
  150. /* openkb() - open keyboard */
  151. openkb()
  152. {SHIFT-+}
  153.   char *rptflg = 0x028a;
  154.  
  155.   open(KB, 0, 0, "");
  156.   /* let the keyboard repeat */
  157.   *rptflg = 0x80; 
  158. {SHIFT--}
  159.  
  160. /* closekb() - close keyboard */
  161. closekb()
  162. {SHIFT-+}
  163.   close(KB);
  164. {SHIFT--}
  165.  
  166. /* getkb() - get char from keyboard */
  167. getkb()
  168. {SHIFT-+}
  169.   return getonechar(KB);
  170. {SHIFT--}
  171.  
  172. /* charsinq() - # available kb chars */
  173. charsinq()
  174. {SHIFT-+}
  175.   char *ndx = 0x00c6;
  176.  
  177.   return (int)*ndx;
  178. {SHIFT--}
  179.  
  180. /* chkstop() - check for <C=> key */
  181. chkstop()
  182. {SHIFT-+}
  183.   char *shflag = 0x028d;
  184.  
  185.   return(*shflag == 0x02);
  186. {SHIFT--}
  187.  
  188. /* getonechar() - get char from chan */
  189. static getonechar(channel)
  190. int channel;
  191. {SHIFT-+}
  192.   char ac, xc, yc;
  193.  
  194.   xc = (char)channel;
  195.   sys(CHKIN, &ac, &xc, &yc);
  196.   sys(GETIN, &ac, &xc, &yc);
  197.   return(int)ac;
  198. {SHIFT--}
  199.  
  200.  
  201. /* disk i/o functions */
  202.  
  203. #define SADDR  0x6f
  204.  
  205. /* diskerr() - read error channel */
  206. char *diskerr(disk)
  207. int disk;
  208. {SHIFT-+}
  209.   int cc;
  210.   char ac, xc, yc;
  211.   static char msgbuf[41];
  212.   char *mp;
  213.   char *second = 0x00b9;
  214.   char *status = 0x0090;
  215.  
  216.   /* tell drive to talk */
  217.   ac = (char)disk;
  218.   sys(TALK, &ac, &xc, &yc);
  219.  
  220.   /* tell it what to talk about */
  221.   ac = (char)SADDR;
  222.   *second = SADDR;
  223.   sys(TKSA, &ac, &xc, &yc);
  224.  
  225.   /* read in the response */
  226.   mp = msgbuf;
  227.   for(;;)
  228.     {SHIFT-+}
  229.     /* get byte from bus in acc */
  230.     sys(ACPTR, &ac, &xc, &yc);
  231.  
  232.     if(ac == '\r')
  233.       {SHIFT-+}
  234.       break;
  235.       {SHIFT--}
  236.     *mp = ac;
  237.     mp++;
  238.     {SHIFT--}
  239.   *mp = '\0';
  240.  
  241.   /* tell drive to shut up */
  242.   sys(UNTLK, &ac, &xc, &yc);
  243.  
  244.   return(msgbuf);
  245. {SHIFT--}
  246.  
  247.  
  248. /* timer functions */
  249.  
  250. unsigned getclock();
  251.  
  252. /* sleep() - sleep for seconds */
  253. sleep(usecs)
  254. unsigned usecs;
  255. {SHIFT-+}
  256.   setclock((unsigned)0);
  257.  
  258.   while(getclock() < usecs)
  259.     {SHIFT-+}
  260.     {SHIFT--}
  261. {SHIFT--}
  262.  
  263. struct clock  /* struct matches CIA */
  264.   {SHIFT-+}
  265.   char tenths;
  266.   char seconds;
  267.   char minutes;
  268.   char hours;
  269.   {SHIFT--};
  270.  
  271. /* setclock() - set timer clock */
  272. setclock(usecs)
  273. unsigned usecs;
  274. {SHIFT-+}
  275.   unsigned bsecs;
  276.   struct clock *clock1 = 0xdc08;
  277.   char *c1mode = 0xdc0f;
  278.  
  279.   *c1mode &= 0x7f;  /* mode is clock */
  280.  
  281.   if(usecs > 59) usecs = 59;
  282.  
  283.   /* convert secs to bcd */
  284.   bsecs = usecs%10 {CBM-*} ((usecs/10)<<4);
  285.  
  286.   clock1->hours = 0;
  287.   clock1->minutes = 0;
  288.   clock1->seconds = (char)bsecs;
  289.   clock1->tenths = 0;  /* free clock */
  290. {SHIFT--}
  291.  
  292. /* getclock() - get current clock secs */
  293. unsigned getclock()
  294. {SHIFT-+}
  295.   unsigned usecs;
  296.   char junk;
  297.   struct clock *clock1 = 0xdc08;
  298.  
  299.   junk = clock1->seconds;
  300.   usecs = (junk & 0x0f) +
  301.           10 * (junk >> 4);
  302.  
  303.   junk = clock1->tenths; /* free clock */
  304.  
  305.   return usecs;
  306. {SHIFT--}
  307.  
  308. /* end of file */
  309.