sys/src/boot/alphapc/cons.c

   1 #include        "u.h"
   2 #include        "mem.h"
   3 #include        "dat.h"
   4 #include        "fns.h"
   5 #include        "lib.h"
   6
   7 enum {
   8         /* prom operations */
   9         Promop_getc   = 1,
  10         Promop_puts   = 2,
  11         Promop_open   = 0x10,
  12         Promop_close  = 0x11,
  13         Promop_read   = 0x13,
  14         Promop_write  = 0x14,
  15         Promop_getenv = 0x22,
  16
  17         /* environment variable indices for getenv */
  18         /* auto_action might be 1; it looks that way. */
  19         Promenv_booted_dev      = 4,
  20         Promenv_booted_file     = 6,
  21         Promenv_booted_osflags  = 8,
  22         Promenv_tty_dev         = 0xf,
  23 };
  24
  25 Hwrpb   *hwrpb;
  26
  27 static uvlong   dispatchf;
  28 static ulong    clk2ms;
  29
  30 void
  31 consinit(void)
  32 {
  33         Procdesc *p;
  34         Hwcrb *crb;
  35         Hwdsr *dsr;
  36         char *s;
  37
  38         hwrpb = (Hwrpb*)0x10000000;
  39
  40         crb = (Hwcrb*)((ulong)hwrpb + hwrpb->crboff);
  41         p = (Procdesc*)(crb->dispatchva);
  42         dispatchf = p->addr;
  43         clk2ms = hwrpb->cfreq/1000;
  44
  45         print("\nAlpha Plan 9 secondary boot\n");
  46         if (hwrpb->rev >= 6) {
  47                 dsr = (Hwdsr*)((ulong)hwrpb + hwrpb->dsroff);
  48                 s = (char*)dsr + dsr->sysnameoff + 8;
  49                 print("%s\n", s);
  50         }
  51 }
  52
  53 uvlong
  54 dispatch(uvlong r16, uvlong r17, uvlong r18, uvlong r19, uvlong r20)
  55 {
  56         return gendispatch(dispatchf, r16, r17, r18, r19, r20);
  57 };
  58
  59 int
  60 devopen(char *s)
  61 {
  62         vlong ret;
  63         int n;
  64
  65         n = strlen(s);
  66         ret = dispatch(0x10, (uvlong)s, n, 0, 0);
  67         if (ret < 0)
  68                 return -1;
  69         return (int) ret;
  70 }
  71
  72 int
  73 devclose(int fd)
  74 {
  75         vlong ret;
  76
  77         ret = dispatch(0x11, fd, 0, 0, 0);
  78         if (ret < 0)
  79                 return -1;
  80         return 0;
  81 }
  82
  83 int
  84 devread(int fd, uchar *buf, int len, int blkno)
  85 {
  86         vlong ret;
  87
  88         ret = dispatch(0x13, fd, len, (uvlong)buf, blkno);
  89         if (ret < 0)
  90                 return -1;
  91         return (int) ret;
  92 }
  93
  94 int
  95 devwrite(int fd, uchar *buf, int len, int blkno)
  96 {
  97         vlong ret;
  98
  99         ret = dispatch(0x14, fd, len, (uvlong)buf, blkno);
 100         if (ret < 0)
 101                 return -1;
 102         return (int) ret;
 103 }
 104
 105 void
 106 dumpenv(void)
 107 {
 108         int id, n;
 109         static char buf[256];
 110
 111         /* old upper bound was 0x100, which blows up on my 164LX. 50 works. */
 112         for (id = 1; id < 50; id++) {
 113                 n = dispatch(Promop_getenv, id, (uvlong)buf, sizeof(buf)-1, 0);
 114                 if (n == 0)
 115                         continue;
 116                 if (n < 0) {
 117                         print("dispatch failed at id %d\n", id);
 118                         break;
 119                 }
 120                 buf[n] = 0;
 121                 print("env[0x%x]: %s\n", id, buf);
 122         }
 123 }
 124
 125 char *
 126 getenv(char *name)
 127 {
 128         int id, n;
 129         static char buf[256];
 130
 131         if (strcmp(name, "booted_dev") == 0)
 132                 id = Promenv_booted_dev;
 133         else
 134                 return 0;
 135         n = dispatch(Promop_getenv, id, (uvlong)buf, sizeof(buf), 0);
 136         if (n < 0)
 137                 return 0;
 138         buf[n] = 0;
 139         return buf;
 140 }
 141
 142 void
 143 putstrn0(char *s, int n)
 144 {
 145         uvlong ret;
 146         int cnt;
 147
 148         for (;;) {
 149                 ret = dispatch(2, 0, (uvlong)s, n, 0);
 150                 cnt = (int) ret;
 151                 s += cnt;
 152                 n -= cnt;
 153                 if (n <= 0)
 154                         break;
 155         }
 156 }
 157
 158 void
 159 putstrn(char *s, int n)
 160 {
 161         char *p;
 162
 163         for (;;) {
 164                 if (n == 0)
 165                         return;
 166                 p = memchr(s, '\n', n);
 167                 if (p == 0) {
 168                         putstrn0(s, n);
 169                         return;
 170                 }
 171                 putstrn0(s, p-s);
 172                 putstrn0("\r\n", 2);
 173                 n -= p-s+1;
 174                 s = p+1;
 175         }
 176 }
 177
 178 int
 179 snprint(char *s, int n, char *fmt, ...)
 180 {
 181         va_list arg;
 182
 183         va_start(arg, fmt);
 184         n = doprint(s, s+n, fmt, arg) - s;
 185         va_end(arg);
 186         return n;
 187 }
 188
 189 int
 190 sprint(char *s, char *fmt, ...)
 191 {
 192         int n;
 193         va_list arg;
 194
 195         va_start(arg, fmt);
 196         n = doprint(s, s+PRINTSIZE, fmt, arg) - s;
 197         va_end(arg);
 198         return n;
 199 }
 200
 201 int
 202 print(char *fmt, ...)
 203 {
 204         int n;
 205         va_list arg;
 206         char buf[PRINTSIZE];
 207
 208         va_start(arg, fmt);
 209         n = doprint(buf, buf+sizeof(buf), fmt, arg) - buf;
 210         va_end(arg);
 211         putstrn(buf, n);
 212
 213         return n;
 214 }
 215
 216 void
 217 panic(char *fmt, ...)
 218 {
 219         int n;
 220         va_list arg;
 221         char buf[PRINTSIZE];
 222
 223         strcpy(buf, "panic: ");
 224         va_start(arg, fmt);
 225         n = doprint(buf+strlen(buf), buf+sizeof(buf), fmt, arg) - buf;
 226         va_end(arg);
 227         buf[n] = '\n';
 228         putstrn(buf, n+1);
 229         firmware();
 230 }
 231
 232 ulong
 233 msec(void)
 234 {
 235         static ulong last, wrap;
 236         ulong cnt;
 237
 238         cnt = pcc_cnt();
 239         if (cnt < last)
 240                 wrap++;
 241         last = cnt;
 242         return (((uvlong)wrap << 32) + cnt)/clk2ms;
 243 }