sys/src/9/pc/yukdump.h

   1 typedef struct Regdump Regdump;
   2 struct Regdump {
   3         uint    offset;
   4         uint    size;
   5         char    *name;
   6 };
   7
   8 Regdump pcireg[] = {
   9         Pciphy, 32,     "Pciphy",
  10         Pciclk, 32,     "Pciclk",
  11         Pcistate,       32,     "Pcistate",
  12 };
  13
  14 static Regdump gmacreg[] = {
  15         Stat,   16,     "Stat",
  16         Ctl,    16,     "Ctl",
  17         Txctl,  16,     "Txctl",
  18         Rxctl,  16,     "Rxctl",
  19         Txflow, 16,     "Txflow",
  20         Txparm, 16,     "Txparm",
  21         Serctl, 16,     "Serctl",
  22         Txirq,  16,     "Txirq",
  23         Rxirq,  16,     "Rxirq",
  24         Trirq,  16,     "Trirq",
  25         Txmask, 16,     "Txmask",
  26         Rxmask, 16,     "Rxmask",
  27         Trmask, 16,     "Trmask",
  28         Smictl, 16,     "Smictl",
  29         Smidata,        16,     "Smidata",
  30         Phyaddr,        16,     "Phyaddr",
  31         Mchash+0,       16,     "Mchash",
  32         Mchash+2,       16,     "Mchash",
  33         Mchash+4,       16,     "Mchash",
  34         Mchash+6,       16,     "Mchash",
  35         Ea0,    16,     "Ea0",
  36         Ea0+2,  16,     "Ea0",
  37         Ea0+4,  16,     "Ea0",
  38         Ea1,    16,     "Ea1",
  39         Ea1+2,  16,     "Ea1",
  40         Ea1+4,  16,     "Ea1",
  41 };
  42
  43 static Regdump macreg[] = {
  44         Txactl, 8,      "Txactl",
  45         Gfrxctl,        32,     "Gfrxctl",
  46         Grxfm,  32,     "Grxfm",
  47         Grxft,  32,     "Grxft",
  48         Grxtt,  32,     "Grxtt",
  49         Gmfctl, 32,     "Gmfctl",
  50         Mac,    32,     "Mac",
  51         Phy,    32,     "Phy",
  52         Irqm,   8,      "Irqm",
  53         Linkctl,        8,      "Linkctl",
  54
  55         Rxwp,   32,     "Rxwp",
  56         Rxrp,   32,     "Rxrp",
  57         Rxrlev, 32,     "Rxrlev",
  58
  59 };
  60
  61 static Regdump reg[] = {
  62         Ctst,   16,     "Ctst",
  63         Pwrctl, 8,      "Pwrctl",
  64         Isr,    32,     "Isr",
  65         Ism,    32,     "Ism",
  66         Hwe,    32,     "Hwe",
  67         Hwem,   32,     "Hwem",
  68         Isrc2,  32,     "Isrc2",
  69
  70         Macadr/2,       16,     "Macadr",
  71         Macadr/2+1,     16,     "Macadr",
  72         Macadr/2+2,     16,     "Macadr",
  73
  74         Pmd,    8,      "Pmd",
  75         Maccfg, 8,      "Maccfg",
  76         Chip,   8,      "Chip",
  77         Ramcnt, 8,      "Ramcnt",
  78         Clkgate,        8,      "Clkgate",
  79         Hres,   8,      "Hres",
  80         Clkctl, 32,     "Clkctl",
  81         Tstctl1,        8,      "Tstctl1",
  82
  83         Asfcs,  8,      "Asfcs",
  84         Asfhost,        32,     "Asfhost",
  85         Statctl,        32,     "Statctl",
  86         Stattl, 16,     "Stattl",
  87         Stataddr,       32,     "Stataddr",
  88         Statth, 16,     "Statth",
  89         Stathd, 16,     "Stathd",
  90         Statwm, 8,      "Statwm",
  91         Statiwm,        8,      "Statiwm",
  92 };
  93
  94 static char*
  95 dumppci(Ctlr *c, char *p, char *e)
  96 {
  97         int i;
  98         Regdump *r;
  99
 100         r = pcireg;
 101         p = seprint(p, e, "/* pci reg */\n");
 102         for(i = 0; i < nelem(pcireg); i++)
 103                 switch(r[i].size){
 104                 default:
 105                         p = seprint(p, e, "%s: bug size %d\n", r[i].name, r[i].size);
 106                         break;
 107                 case 32:
 108                         p = seprint(p, e, "%s: %.8ux\n", r[i].name, pcicfgr32(c->p, r[i].offset));
 109                         break;
 110                 }
 111         return p;
 112 }
 113
 114 static char*
 115 dumpgmac(Ctlr *c, char *p, char *e)
 116 {
 117         int i;
 118         Regdump *r;
 119
 120         r = gmacreg;
 121         p = seprint(p, e, "/* gmac reg */\n");
 122         for(i = 0; i < nelem(gmacreg); i++)
 123                 switch(r[i].size){
 124                 default:
 125                         p = seprint(p, e, "%s: bug size %d\n", r[i].name, r[i].size);
 126                         break;
 127                 case 16:
 128                         p = seprint(p, e, "%s: %.4ux\n", r[i].name, gmacread(c, r[i].offset));
 129                         break;
 130                 case 32:
 131                         p = seprint(p, e, "%s: %.8ux\n", r[i].name, gmacread32(c, r[i].offset));
 132                         break;
 133                 }
 134         return p;
 135 }
 136
 137 static char*
 138 dumpmac(Ctlr *c, char *p, char *e)
 139 {
 140         int i;
 141         Regdump *r;
 142
 143         r = macreg;
 144         p = seprint(p, e, "/* mac reg */\n");
 145         for(i = 0; i < nelem(macreg); i++)
 146                 switch(r[i].size){
 147                 default:
 148                         p = seprint(p, e, "%s: bug size %d\n", r[i].name, r[i].size);
 149                         break;
 150                 case 8:
 151                         p = seprint(p, e, "%s: %.2ux\n", r[i].name, macread8(c, r[i].offset));
 152                         break;
 153                 case 32:
 154                         p = seprint(p, e, "%s: %.8ux\n", r[i].name, macread32(c, r[i].offset));
 155                         break;
 156                 }
 157         return p;
 158 }
 159
 160 static char*
 161 dumpreg(Ctlr *c, char *p, char *e)
 162 {
 163         int i;
 164         Regdump *r;
 165
 166         r = reg;
 167         p = seprint(p, e, "/* reg */\n");
 168         for(i = 0; i < nelem(reg); i++)
 169                 switch(r[i].size){
 170                 default:
 171                         p = seprint(p, e, "%s: bug size %d\n", r[i].name, r[i].size);
 172                         break;
 173                 case 8:
 174                         p = seprint(p, e, "%s: %.2ux\n", r[i].name, c->reg8[r[i].offset]);
 175                         break;
 176                 case 16:
 177                         p = seprint(p, e, "%s: %.4ux\n", r[i].name, c->reg16[r[i].offset]);
 178                         break;
 179                 case 32:
 180                         p = seprint(p, e, "%s: %.8ux\n", r[i].name, c->reg[r[i].offset]);
 181                         break;
 182                 }
 183         return p;
 184 }
 185
 186 static char *optab[256] = {
 187 [Orxchks]       "rxsum",
 188 [Orxstat]               "rxstat",
 189 [Otxidx]                "txidx",
 190 };
 191
 192 static char*
 193 rs(uint r)
 194 {
 195         char *s;
 196
 197         s = optab[r & 0xff];
 198         if(s == nil)
 199                 s = "";
 200         return s;
 201 }
 202
 203 static char*
 204 dumpring(Sring *r, Block **t, char *p, char *e)
 205 {
 206         int m, n;
 207         uint i;
 208
 209         p = seprint(p, e,
 210                 "bring: rp %ud wp %ud cnt %ud m %ud     : ",
 211                 r->rp, r->wp, r->cnt, r->m);
 212         m = -1;
 213         n = 0;
 214         for(i = 0; i < r->cnt; i++){
 215                 n += t[i] != nil;
 216                 if(m>=0 && t[i] == nil){
 217                         p = seprint(p, e, "%ud", m);
 218                         if(i != m + 1)
 219                                 p = seprint(p, e, "-%ud", i-1);
 220                         p = seprint(p, e, " ");
 221                         m = -1;
 222                 }else if(m<0 && t[i] != nil)
 223                         m = i;
 224         }
 225         if(m>=0){
 226                 p = seprint(p, e, "%ud", m);
 227                 if(i != m + 1)
 228                         p = seprint(p, e, "-%ud ", i-1);
 229         }
 230         return seprint(p, e, "n=%d/%d", n, r->cnt);
 231 }
 232
 233 /* debug; remove */
 234 static void
 235 descriptorfu(Ether *e, uint qoff)
 236 {
 237         char buf[PRINTSIZE], *p, *f;
 238         uint q, qm1;
 239         Block *b, *a, **bring;
 240         Ctlr *c;
 241         Status *t, *v;
 242         Sring *r;
 243
 244         c = e->ctlr;
 245         f = buf + sizeof buf;
 246         if(qoff == Qtx){
 247                 bring = c->tbring;
 248                 r = &c->tx;
 249                 p = seprint(buf, f, "tx ");
 250         }else{
 251                 bring = c->rbring;
 252                 r = &c->rx;
 253                 p = seprint(buf, f, "rx ");
 254         }
 255
 256         q = prread16(c, qoff + Pgetidx);
 257         print("  getidx %ud\n", q);
 258         if(q >= r->cnt){
 259                 q &= r->m;
 260                 print("  try getidx %ud\n", q);
 261         }
 262         qm1 = q-1 & r->m;
 263         t = r->r + q;
 264         v = r->r + qm1;
 265         b = bring[q];
 266         a = bring[qm1];
 267         print(" %0.4d %.2ux     l=%d p=%#p @%#p\n", q, t->op,
 268                 (uint)getle(t->l, 2), KZERO+(ulong)getle(t->status, 4), Pciwaddrl(t));
 269         print(" %0.4d %.2ux     l=%d p=%#p @%#p\n", qm1, t->op,
 270                 (uint)getle(v->l, 2), KZERO+(ulong)getle(v->status, 4), Pciwaddrl(v));
 271         if(r == &c->rx)
 272                 print(" %#p %#p  (wp)\n", b? b->wp: 0, a? a->wp: 0);
 273         else
 274                 print(" %#p %#p  (rp)\n", b? b->rp: 0, a? a->rp: 0);
 275
 276         dumpring(r, bring, p, f);
 277         print(" %s", buf);
 278 }