ROM2/helpers.c

   1 #include "display_basic.h"
   2 #include "vend.h"
   3
   4 void delay(u16 ms) {
   5         /* delay routine written in assembly so we know what we're really getting.
   6          * each inner loop should take ~1 ms to execute.
   7          * 15 cycles * (1/4.9152Mhz) * 327 = 0.997 ms + a little bit on the fringes.
   8          *
   9          * XXX - how do we know gcc isn't optimising this? it seems to optimise after
  10          * parsing C -> asm, but before asm -> machine code.
  11          */
  12         //asm volatile ("pshx\npsha\npshb\n"); /* save registers */
  13         asm volatile ("ldx %0\n" :: "m" (ms) : "x");
  14         asm volatile (
  15                 "delay_loop:\n"
  16                 //"     ldd #327\n"                   /* 3 */
  17                 "       ldd #150\n"                   /* 3 */
  18                 "delay_inner_loop:\n" /* 15 cycles each */
  19                 "       cpd #0x0000\n"                /* 5 */
  20                 "       beq delay_inner_loop_end\n"   /* 3 */
  21                 "       subd #0x0001\n"               /* 4 */
  22                 "       bra delay_inner_loop\n"       /* 3 */
  23                 "delay_inner_loop_end:\n"
  24                 "       dex\n"                        /* 3 */
  25                 "       beq delay_out\n"              /* 3 */
  26                 "       bra delay_loop\n"             /* 3 */
  27                 "delay_out:\n" ::: "x", "d");
  28                 /*"     pulb\n"
  29                 "       pula\n"
  30                 "       pulx\n");*/
  31 }
  32
  33 u8 my_strlen(char* s) {
  34         char *p = s;
  35         while (*p) p++;
  36         return p-s;
  37 }
  38
  39 void my_strncpy(char* dst, char* src, u8 max_size) {
  40         u8 i;
  41         for (i = 0; src[i] && i < max_size; i++) dst[i] = src[i];
  42         if (src[i] == 0 && i < max_size) dst[i] = 0; /* null terminator */
  43 }
  44
  45 bool my_strncmp(char* a, char* b, u8 len) {
  46         u8 i;
  47         for (i = 0; i < len; i++) {
  48                 if (*a != *b) return 0;
  49                 a++;
  50                 b++;
  51         }
  52         return 1;
  53 }
  54
  55 void my_memcpy(char* dst, char* src, u8 size) {
  56         u8 i = 0;
  57         for (i = 0; i < size; i++) dst[i] = src[i];
  58 }
  59
  60 void my_memset(char* dst, u8 val, u16 count) {
  61         char* c;
  62         for (c = dst; c < dst+count; c++) *c = val;
  63 }
  64
  65 u8 hexchar2u8(char b) {
  66         if (b >= '0' && b <= '9') return b-'0';
  67         if (b >= 'a' && b <= 'f') return b-'a'+0x0a;
  68         if (b >= 'A' && b <= 'F') return b-'A'+0x0a;
  69         return 0;
  70 }
  71
  72 char nibble2hexchar(u8 b) {
  73         if (b <= 9) return b+'0';
  74         if (b >= 10 && b <= 15) return b+'A'-10;
  75         return 'X';
  76 }
  77
  78 u8 hex2u8(char msb, char lsb) {
  79         return (hexchar2u8(msb) << 4) + hexchar2u8(lsb);
  80 }
  81
  82 static char hexconv_buf[3];
  83 char* u82hex(u8 a) {
  84         hexconv_buf[0] = nibble2hexchar((a&0xf0) >> 4);
  85         hexconv_buf[1] = nibble2hexchar(a&0x0f);
  86         hexconv_buf[2] = '\0';
  87         return hexconv_buf;
  88 }
  89