|
@@ -3,7 +3,7 @@
|
|
* © 2007 erik quanstrom, coraid
|
|
* © 2007 erik quanstrom, coraid
|
|
*
|
|
*
|
|
* the card is big endian.
|
|
* the card is big endian.
|
|
- * we use u64int rather than uintptr to hold addresses so that
|
|
|
|
|
|
+ * we use uvlong rather than uintptr to hold addresses so that
|
|
* we don't get "warning: stupid shift" on 32-bit architectures.
|
|
* we don't get "warning: stupid shift" on 32-bit architectures.
|
|
*/
|
|
*/
|
|
#include "u.h"
|
|
#include "u.h"
|
|
@@ -97,8 +97,8 @@ typedef union {
|
|
|
|
|
|
typedef ulong Slot;
|
|
typedef ulong Slot;
|
|
typedef struct {
|
|
typedef struct {
|
|
- u16int cksum;
|
|
|
|
- u16int len;
|
|
|
|
|
|
+ ushort cksum;
|
|
|
|
+ ushort len;
|
|
} Slotparts;
|
|
} Slotparts;
|
|
|
|
|
|
enum {
|
|
enum {
|
|
@@ -109,10 +109,10 @@ enum {
|
|
};
|
|
};
|
|
|
|
|
|
typedef struct {
|
|
typedef struct {
|
|
- u32int high;
|
|
|
|
- u32int low;
|
|
|
|
- u16int hdroff;
|
|
|
|
- u16int len;
|
|
|
|
|
|
+ ulong high;
|
|
|
|
+ ulong low;
|
|
|
|
+ ushort hdroff;
|
|
|
|
+ ushort len;
|
|
uchar pad;
|
|
uchar pad;
|
|
uchar nrdma;
|
|
uchar nrdma;
|
|
uchar chkoff;
|
|
uchar chkoff;
|
|
@@ -126,7 +126,7 @@ typedef struct {
|
|
Block **bring;
|
|
Block **bring;
|
|
// uchar *wcfifo; /* what the heck is a w/c fifo? */
|
|
// uchar *wcfifo; /* what the heck is a w/c fifo? */
|
|
int size; /* of buffers in the z8's memory */
|
|
int size; /* of buffers in the z8's memory */
|
|
- u32int segsz;
|
|
|
|
|
|
+ ulong segsz;
|
|
uint n; /* rxslots */
|
|
uint n; /* rxslots */
|
|
uint m; /* mask; rxslots must be a power of two */
|
|
uint m; /* mask; rxslots must be a power of two */
|
|
uint i; /* number of segments (not frames) queued */
|
|
uint i; /* number of segments (not frames) queued */
|
|
@@ -149,7 +149,7 @@ static Bpool bgpool = { .size = Maxmtu, };
|
|
|
|
|
|
typedef struct {
|
|
typedef struct {
|
|
Bpool *pool; /* free buffers */
|
|
Bpool *pool; /* free buffers */
|
|
- u32int *lanai; /* rx ring; we have no permanent host shadow */
|
|
|
|
|
|
+ ulong *lanai; /* rx ring; we have no permanent host shadow */
|
|
Block **host; /* called "info" in myricom driver */
|
|
Block **host; /* called "info" in myricom driver */
|
|
// uchar *wcfifo; /* cmd submission fifo */
|
|
// uchar *wcfifo; /* cmd submission fifo */
|
|
uint m;
|
|
uint m;
|
|
@@ -184,7 +184,7 @@ enum {
|
|
|
|
|
|
typedef struct {
|
|
typedef struct {
|
|
Slot *entry;
|
|
Slot *entry;
|
|
- u64int busaddr;
|
|
|
|
|
|
+ uvlong busaddr;
|
|
uint m;
|
|
uint m;
|
|
uint n;
|
|
uint n;
|
|
uint i;
|
|
uint i;
|
|
@@ -195,7 +195,7 @@ typedef struct Ctlr {
|
|
QLock;
|
|
QLock;
|
|
int state;
|
|
int state;
|
|
int kprocs;
|
|
int kprocs;
|
|
- u64int port;
|
|
|
|
|
|
+ uvlong port;
|
|
Pcidev* pcidev;
|
|
Pcidev* pcidev;
|
|
Ctlr* next;
|
|
Ctlr* next;
|
|
int active;
|
|
int active;
|
|
@@ -206,32 +206,32 @@ typedef struct Ctlr {
|
|
int ramsz;
|
|
int ramsz;
|
|
uchar *ram;
|
|
uchar *ram;
|
|
|
|
|
|
- u32int *irqack;
|
|
|
|
- u32int *irqdeass;
|
|
|
|
- u32int *coal;
|
|
|
|
|
|
+ ulong *irqack;
|
|
|
|
+ ulong *irqdeass;
|
|
|
|
+ ulong *coal;
|
|
|
|
|
|
char eprom[Epromsz];
|
|
char eprom[Epromsz];
|
|
ulong serial; /* unit serial number */
|
|
ulong serial; /* unit serial number */
|
|
|
|
|
|
QLock cmdl;
|
|
QLock cmdl;
|
|
Cmd *cmd; /* address of command return */
|
|
Cmd *cmd; /* address of command return */
|
|
- u64int cprt; /* bus address of command */
|
|
|
|
|
|
+ uvlong cprt; /* bus address of command */
|
|
|
|
|
|
- u64int boot; /* boot address */
|
|
|
|
|
|
+ uvlong boot; /* boot address */
|
|
|
|
|
|
Done done;
|
|
Done done;
|
|
Tx tx;
|
|
Tx tx;
|
|
Rx sm;
|
|
Rx sm;
|
|
Rx bg;
|
|
Rx bg;
|
|
Stats *stats;
|
|
Stats *stats;
|
|
- u64int statsprt;
|
|
|
|
|
|
+ uvlong statsprt;
|
|
|
|
|
|
Rendez rxrendez;
|
|
Rendez rxrendez;
|
|
Rendez txrendez;
|
|
Rendez txrendez;
|
|
|
|
|
|
int msi;
|
|
int msi;
|
|
- u32int linkstat;
|
|
|
|
- u32int nrdma;
|
|
|
|
|
|
+ ulong linkstat;
|
|
|
|
+ ulong nrdma;
|
|
} Ctlr;
|
|
} Ctlr;
|
|
|
|
|
|
static Ctlr *ctlrs;
|
|
static Ctlr *ctlrs;
|
|
@@ -332,7 +332,7 @@ whichfw(Pcidev *p)
|
|
{
|
|
{
|
|
char *s;
|
|
char *s;
|
|
int i, off, lanes, ecrc;
|
|
int i, off, lanes, ecrc;
|
|
- u32int cap;
|
|
|
|
|
|
+ ulong cap;
|
|
|
|
|
|
/* check the number of configured lanes. */
|
|
/* check the number of configured lanes. */
|
|
off = pcicap(p, PciCapPCIe);
|
|
off = pcicap(p, PciCapPCIe);
|
|
@@ -349,7 +349,7 @@ whichfw(Pcidev *p)
|
|
if(off != 0){
|
|
if(off != 0){
|
|
off += AercCCR;
|
|
off += AercCCR;
|
|
cap = pcicfgr32(p, off);
|
|
cap = pcicfgr32(p, off);
|
|
- print("%ud cap\n", cap);
|
|
|
|
|
|
+ print("%lud cap\n", cap);
|
|
}
|
|
}
|
|
ecrc = (cap>>4) & 0xf;
|
|
ecrc = (cap>>4) & 0xf;
|
|
/* if we don't like the aerc, kick it here. */
|
|
/* if we don't like the aerc, kick it here. */
|
|
@@ -402,10 +402,10 @@ parseeprom(Ctlr *c)
|
|
return 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
-static u16int
|
|
|
|
-pbit16(u16int i)
|
|
|
|
|
|
+static ushort
|
|
|
|
+pbit16(ushort i)
|
|
{
|
|
{
|
|
- u16int j;
|
|
|
|
|
|
+ ushort j;
|
|
uchar *p;
|
|
uchar *p;
|
|
|
|
|
|
p = (uchar*)&j;
|
|
p = (uchar*)&j;
|
|
@@ -414,20 +414,20 @@ pbit16(u16int i)
|
|
return j;
|
|
return j;
|
|
}
|
|
}
|
|
|
|
|
|
-static u16int
|
|
|
|
|
|
+static ushort
|
|
gbit16(uchar i[2])
|
|
gbit16(uchar i[2])
|
|
{
|
|
{
|
|
- u16int j;
|
|
|
|
|
|
+ ushort j;
|
|
|
|
|
|
j = i[1];
|
|
j = i[1];
|
|
j |= i[0]<<8;
|
|
j |= i[0]<<8;
|
|
return j;
|
|
return j;
|
|
}
|
|
}
|
|
|
|
|
|
-static u32int
|
|
|
|
-pbit32(u32int i)
|
|
|
|
|
|
+static ulong
|
|
|
|
+pbit32(ulong i)
|
|
{
|
|
{
|
|
- u32int j;
|
|
|
|
|
|
+ ulong j;
|
|
uchar *p;
|
|
uchar *p;
|
|
|
|
|
|
p = (uchar*)&j;
|
|
p = (uchar*)&j;
|
|
@@ -438,10 +438,10 @@ pbit32(u32int i)
|
|
return j;
|
|
return j;
|
|
}
|
|
}
|
|
|
|
|
|
-static u32int
|
|
|
|
|
|
+static ulong
|
|
gbit32(uchar i[4])
|
|
gbit32(uchar i[4])
|
|
{
|
|
{
|
|
- u32int j;
|
|
|
|
|
|
+ ulong j;
|
|
|
|
|
|
j = i[3];
|
|
j = i[3];
|
|
j |= i[2]<<8;
|
|
j |= i[2]<<8;
|
|
@@ -451,7 +451,7 @@ gbit32(uchar i[4])
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
static void
|
|
-prepcmd(uint *cmd, int i)
|
|
|
|
|
|
+prepcmd(ulong *cmd, int i)
|
|
{
|
|
{
|
|
while(i-- > 0)
|
|
while(i-- > 0)
|
|
cmd[i] = pbit32(cmd[i]);
|
|
cmd[i] = pbit32(cmd[i]);
|
|
@@ -468,10 +468,10 @@ prepcmd(uint *cmd, int i)
|
|
* 40 byte = 5 int pad.
|
|
* 40 byte = 5 int pad.
|
|
*/
|
|
*/
|
|
|
|
|
|
-u32int
|
|
|
|
-cmd(Ctlr *c, int type, u64int data)
|
|
|
|
|
|
+ulong
|
|
|
|
+cmd(Ctlr *c, int type, uvlong data)
|
|
{
|
|
{
|
|
- u32int buf[16], i;
|
|
|
|
|
|
+ ulong buf[16], i;
|
|
Cmd *cmd;
|
|
Cmd *cmd;
|
|
|
|
|
|
qlock(&c->cmdl);
|
|
qlock(&c->cmdl);
|
|
@@ -495,7 +495,7 @@ cmd(Ctlr *c, int type, u64int data)
|
|
i = gbit32(cmd->c);
|
|
i = gbit32(cmd->c);
|
|
qunlock(&c->cmdl);
|
|
qunlock(&c->cmdl);
|
|
if(cmd->i[1] != 0)
|
|
if(cmd->i[1] != 0)
|
|
- dprint("[%ux]", i);
|
|
|
|
|
|
+ dprint("[%lux]", i);
|
|
return i;
|
|
return i;
|
|
}
|
|
}
|
|
tsleep(&up->sleep, return0, 0, 1);
|
|
tsleep(&up->sleep, return0, 0, 1);
|
|
@@ -507,10 +507,10 @@ cmd(Ctlr *c, int type, u64int data)
|
|
return ~0; /* silence! */
|
|
return ~0; /* silence! */
|
|
}
|
|
}
|
|
|
|
|
|
-u32int
|
|
|
|
|
|
+ulong
|
|
maccmd(Ctlr *c, int type, uchar *m)
|
|
maccmd(Ctlr *c, int type, uchar *m)
|
|
{
|
|
{
|
|
- u32int buf[16], i;
|
|
|
|
|
|
+ ulong buf[16], i;
|
|
Cmd *cmd;
|
|
Cmd *cmd;
|
|
|
|
|
|
qlock(&c->cmdl);
|
|
qlock(&c->cmdl);
|
|
@@ -534,7 +534,7 @@ maccmd(Ctlr *c, int type, uchar *m)
|
|
i = gbit32(cmd->c);
|
|
i = gbit32(cmd->c);
|
|
qunlock(&c->cmdl);
|
|
qunlock(&c->cmdl);
|
|
if(cmd->i[1] != 0)
|
|
if(cmd->i[1] != 0)
|
|
- dprint("[%ux]", i);
|
|
|
|
|
|
+ dprint("[%lux]", i);
|
|
return i;
|
|
return i;
|
|
}
|
|
}
|
|
tsleep(&up->sleep, return0, 0, 1);
|
|
tsleep(&up->sleep, return0, 0, 1);
|
|
@@ -552,10 +552,10 @@ enum {
|
|
DMAwrite= 0x1,
|
|
DMAwrite= 0x1,
|
|
};
|
|
};
|
|
|
|
|
|
-u32int
|
|
|
|
-dmatestcmd(Ctlr *c, int type, u64int addr, int len)
|
|
|
|
|
|
+ulong
|
|
|
|
+dmatestcmd(Ctlr *c, int type, uvlong addr, int len)
|
|
{
|
|
{
|
|
- u32int buf[16], i;
|
|
|
|
|
|
+ ulong buf[16], i;
|
|
|
|
|
|
memset(buf, 0, sizeof buf);
|
|
memset(buf, 0, sizeof buf);
|
|
memset(c->cmd, Noconf, sizeof *c->cmd);
|
|
memset(c->cmd, Noconf, sizeof *c->cmd);
|
|
@@ -585,10 +585,10 @@ dmatestcmd(Ctlr *c, int type, u64int addr, int len)
|
|
return ~0; /* silence! */
|
|
return ~0; /* silence! */
|
|
}
|
|
}
|
|
|
|
|
|
-u32int
|
|
|
|
|
|
+ulong
|
|
rdmacmd(Ctlr *c, int on)
|
|
rdmacmd(Ctlr *c, int on)
|
|
{
|
|
{
|
|
- u32int buf[16], i;
|
|
|
|
|
|
+ ulong buf[16], i;
|
|
|
|
|
|
memset(buf, 0, sizeof buf);
|
|
memset(buf, 0, sizeof buf);
|
|
c->cmd->i[0] = 0;
|
|
c->cmd->i[0] = 0;
|
|
@@ -619,18 +619,18 @@ rdmacmd(Ctlr *c, int on)
|
|
static int
|
|
static int
|
|
loadfw(Ctlr *c, int *align)
|
|
loadfw(Ctlr *c, int *align)
|
|
{
|
|
{
|
|
- uint *f, *s, sz;
|
|
|
|
|
|
+ ulong *f, *s, sz;
|
|
int i;
|
|
int i;
|
|
|
|
|
|
if((*align = whichfw(c->pcidev)) == 4*KiB){
|
|
if((*align = whichfw(c->pcidev)) == 4*KiB){
|
|
- f = (u32int*)fw4k;
|
|
|
|
|
|
+ f = (ulong*)fw4k;
|
|
sz = sizeof fw4k;
|
|
sz = sizeof fw4k;
|
|
}else{
|
|
}else{
|
|
- f = (u32int*)fw2k;
|
|
|
|
|
|
+ f = (ulong*)fw2k;
|
|
sz = sizeof fw2k;
|
|
sz = sizeof fw2k;
|
|
}
|
|
}
|
|
|
|
|
|
- s = (u32int*)(c->ram + Fwoffset);
|
|
|
|
|
|
+ s = (ulong*)(c->ram + Fwoffset);
|
|
for(i = 0; i < sz / 4; i++)
|
|
for(i = 0; i < sz / 4; i++)
|
|
s[i] = f[i];
|
|
s[i] = f[i];
|
|
return sz & ~3;
|
|
return sz & ~3;
|
|
@@ -640,7 +640,7 @@ static int
|
|
bootfw(Ctlr *c)
|
|
bootfw(Ctlr *c)
|
|
{
|
|
{
|
|
int i, sz, align;
|
|
int i, sz, align;
|
|
- uint buf[16];
|
|
|
|
|
|
+ ulong buf[16];
|
|
Cmd* cmd;
|
|
Cmd* cmd;
|
|
|
|
|
|
if((sz = loadfw(c, &align)) == 0)
|
|
if((sz = loadfw(c, &align)) == 0)
|
|
@@ -667,7 +667,7 @@ bootfw(Ctlr *c)
|
|
break;
|
|
break;
|
|
delay(1);
|
|
delay(1);
|
|
}
|
|
}
|
|
- dprint("[%ux %ux]", gbit32(cmd->c), gbit32(cmd->c+4));
|
|
|
|
|
|
+ dprint("[%lux %lux]", gbit32(cmd->c), gbit32(cmd->c+4));
|
|
if(i == 20){
|
|
if(i == 20){
|
|
print("m10g: cannot load fw\n");
|
|
print("m10g: cannot load fw\n");
|
|
return -1;
|
|
return -1;
|
|
@@ -681,13 +681,13 @@ static int
|
|
kickthebaby(Pcidev *p, Ctlr *c)
|
|
kickthebaby(Pcidev *p, Ctlr *c)
|
|
{
|
|
{
|
|
/* don't kick the baby! */
|
|
/* don't kick the baby! */
|
|
- u32int code;
|
|
|
|
|
|
+ ulong code;
|
|
|
|
|
|
pcicfgw8(p, 0x10 + c->boot, 0x3);
|
|
pcicfgw8(p, 0x10 + c->boot, 0x3);
|
|
pcicfgw32(p, 0x18 + c->boot, 0xfffffff0);
|
|
pcicfgw32(p, 0x18 + c->boot, 0xfffffff0);
|
|
code = pcicfgr32(p, 0x14 + c->boot);
|
|
code = pcicfgr32(p, 0x14 + c->boot);
|
|
|
|
|
|
- dprint("reboot status = %ux\n", code);
|
|
|
|
|
|
+ dprint("reboot status = %lux\n", code);
|
|
if(code != 0xfffffff0)
|
|
if(code != 0xfffffff0)
|
|
return -1;
|
|
return -1;
|
|
return 0;
|
|
return 0;
|
|
@@ -711,7 +711,7 @@ enum {
|
|
};
|
|
};
|
|
|
|
|
|
static char *
|
|
static char *
|
|
-fwtype(u32int type)
|
|
|
|
|
|
+fwtype(ulong type)
|
|
{
|
|
{
|
|
switch(type){
|
|
switch(type){
|
|
case Tmx:
|
|
case Tmx:
|
|
@@ -731,19 +731,19 @@ chkfw(Ctlr *c)
|
|
{
|
|
{
|
|
uintptr off;
|
|
uintptr off;
|
|
Fwhdr *h;
|
|
Fwhdr *h;
|
|
- u32int type;
|
|
|
|
|
|
+ ulong type;
|
|
|
|
|
|
off = gbit32(c->ram+0x3c);
|
|
off = gbit32(c->ram+0x3c);
|
|
- dprint("firmware %llux\n", (u64int)off);
|
|
|
|
|
|
+ dprint("firmware %llux\n", (uvlong)off);
|
|
if((off&3) || off + sizeof *h > c->ramsz){
|
|
if((off&3) || off + sizeof *h > c->ramsz){
|
|
- print("!m10g: bad firmware %llux\n", (u64int)off);
|
|
|
|
|
|
+ print("!m10g: bad firmware %llux\n", (uvlong)off);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
h = (Fwhdr*)(c->ram + off);
|
|
h = (Fwhdr*)(c->ram + off);
|
|
type = gbit32(h->type);
|
|
type = gbit32(h->type);
|
|
dprint("\t" "type %s\n", fwtype(type));
|
|
dprint("\t" "type %s\n", fwtype(type));
|
|
dprint("\t" "vers %s\n", h->version);
|
|
dprint("\t" "vers %s\n", h->version);
|
|
- dprint("\t" "ramsz %ux\n", gbit32(h->ramsz));
|
|
|
|
|
|
+ dprint("\t" "ramsz %lux\n", gbit32(h->ramsz));
|
|
if(type != Teth){
|
|
if(type != Teth){
|
|
print("!m10g: bad card type %s\n", fwtype(type));
|
|
print("!m10g: bad card type %s\n", fwtype(type));
|
|
return -1;
|
|
return -1;
|
|
@@ -755,7 +755,7 @@ chkfw(Ctlr *c)
|
|
static int
|
|
static int
|
|
reset(Ether *e, Ctlr *c)
|
|
reset(Ether *e, Ctlr *c)
|
|
{
|
|
{
|
|
- u32int i, sz;
|
|
|
|
|
|
+ ulong i, sz;
|
|
|
|
|
|
if(waserror()){
|
|
if(waserror()){
|
|
print("m10g: reset error\n");
|
|
print("m10g: reset error\n");
|
|
@@ -768,22 +768,22 @@ reset(Ether *e, Ctlr *c)
|
|
|
|
|
|
cmd(c, CSintrqsz, c->done.n * sizeof *c->done.entry);
|
|
cmd(c, CSintrqsz, c->done.n * sizeof *c->done.entry);
|
|
cmd(c, CSintrqdma, c->done.busaddr);
|
|
cmd(c, CSintrqdma, c->done.busaddr);
|
|
- c->irqack = (u32int*)(c->ram + cmd(c, CGirqackoff, 0));
|
|
|
|
|
|
+ c->irqack = (ulong*)(c->ram + cmd(c, CGirqackoff, 0));
|
|
/* required only if we're not doing msi? */
|
|
/* required only if we're not doing msi? */
|
|
- c->irqdeass = (u32int*)(c->ram + cmd(c, CGirqdeassoff, 0));
|
|
|
|
|
|
+ c->irqdeass = (ulong*)(c->ram + cmd(c, CGirqdeassoff, 0));
|
|
/* this is the driver default, why fiddle with this? */
|
|
/* this is the driver default, why fiddle with this? */
|
|
- c->coal = (u32int*)(c->ram + cmd(c, CGcoaloff, 0));
|
|
|
|
|
|
+ c->coal = (ulong*)(c->ram + cmd(c, CGcoaloff, 0));
|
|
*c->coal = pbit32(25);
|
|
*c->coal = pbit32(25);
|
|
|
|
|
|
dprint("dma stats:\n");
|
|
dprint("dma stats:\n");
|
|
rdmacmd(c, 1);
|
|
rdmacmd(c, 1);
|
|
sz = c->tx.segsz;
|
|
sz = c->tx.segsz;
|
|
i = dmatestcmd(c, DMAread, c->done.busaddr, sz);
|
|
i = dmatestcmd(c, DMAread, c->done.busaddr, sz);
|
|
- print("\t" "read: %ud MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
|
|
|
|
|
|
+ print("\t" "read: %lud MB/s\n", ((i>>16)*sz*2) / (i&0xffff));
|
|
i = dmatestcmd(c, DMAwrite, c->done.busaddr, sz);
|
|
i = dmatestcmd(c, DMAwrite, c->done.busaddr, sz);
|
|
- print("\t" "write: %ud MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
|
|
|
|
|
|
+ print("\t" "write: %lud MB/s\n", ((i>>16)*sz*2) / (i&0xffff));
|
|
i = dmatestcmd(c, DMAwrite|DMAread, c->done.busaddr, sz);
|
|
i = dmatestcmd(c, DMAwrite|DMAread, c->done.busaddr, sz);
|
|
- print("\t" "r/w: %ud MB/s\n", ((i>>16)*sz*2*2)/(i&0xffff));
|
|
|
|
|
|
+ print("\t" "r/w: %lud MB/s\n", ((i>>16)*sz*2*2) / (i&0xffff));
|
|
memset(c->done.entry, 0, c->done.n * sizeof *c->done.entry);
|
|
memset(c->done.entry, 0, c->done.n * sizeof *c->done.entry);
|
|
|
|
|
|
maccmd(c, CSmac, c->ra);
|
|
maccmd(c, CSmac, c->ra);
|
|
@@ -813,8 +813,8 @@ ctlrfree(Ctlr *c)
|
|
static int
|
|
static int
|
|
setmem(Pcidev *p, Ctlr *c)
|
|
setmem(Pcidev *p, Ctlr *c)
|
|
{
|
|
{
|
|
- u32int i;
|
|
|
|
- u64int raddr;
|
|
|
|
|
|
+ ulong i;
|
|
|
|
+ uvlong raddr;
|
|
Done *d;
|
|
Done *d;
|
|
void *mem;
|
|
void *mem;
|
|
|
|
|
|
@@ -907,7 +907,7 @@ bgbfree(Block *b)
|
|
static void
|
|
static void
|
|
replenish(Rx *rx)
|
|
replenish(Rx *rx)
|
|
{
|
|
{
|
|
- u32int buf[16], i, idx, e;
|
|
|
|
|
|
+ ulong buf[16], i, idx, e;
|
|
Bpool *p;
|
|
Bpool *p;
|
|
Block *b;
|
|
Block *b;
|
|
|
|
|
|
@@ -921,7 +921,7 @@ replenish(Rx *rx)
|
|
idx = rx->cnt & rx->m;
|
|
idx = rx->cnt & rx->m;
|
|
for(i = 0; i < 8; i++){
|
|
for(i = 0; i < 8; i++){
|
|
b = balloc(rx);
|
|
b = balloc(rx);
|
|
- buf[i*2] = pbit32((u64int)PCIWADDR(b->wp) >> 32);
|
|
|
|
|
|
+ buf[i*2] = pbit32((uvlong)PCIWADDR(b->wp) >> 32);
|
|
buf[i*2+1] = pbit32(PCIWADDR(b->wp));
|
|
buf[i*2+1] = pbit32(PCIWADDR(b->wp));
|
|
rx->host[idx+i] = b;
|
|
rx->host[idx+i] = b;
|
|
assert(b);
|
|
assert(b);
|
|
@@ -982,7 +982,7 @@ open0(Ether *e, Ctlr *c)
|
|
entries = cmd(c, CGrxrgsz, 0)/8;
|
|
entries = cmd(c, CGrxrgsz, 0)/8;
|
|
c->sm.pool = &smpool;
|
|
c->sm.pool = &smpool;
|
|
cmd(c, CSsmallsz, c->sm.pool->size);
|
|
cmd(c, CSsmallsz, c->sm.pool->size);
|
|
- c->sm.lanai = (u32int*)(c->ram + cmd(c, CGsmallrxoff, 0));
|
|
|
|
|
|
+ c->sm.lanai = (ulong*)(c->ram + cmd(c, CGsmallrxoff, 0));
|
|
c->sm.n = entries;
|
|
c->sm.n = entries;
|
|
c->sm.m = entries-1;
|
|
c->sm.m = entries-1;
|
|
c->sm.host = emalign(entries * sizeof *c->sm.host);
|
|
c->sm.host = emalign(entries * sizeof *c->sm.host);
|
|
@@ -990,7 +990,7 @@ open0(Ether *e, Ctlr *c)
|
|
c->bg.pool = &bgpool;
|
|
c->bg.pool = &bgpool;
|
|
c->bg.pool->size = nextpow(2 + e->maxmtu); /* 2-byte alignment pad */
|
|
c->bg.pool->size = nextpow(2 + e->maxmtu); /* 2-byte alignment pad */
|
|
cmd(c, CSbigsz, c->bg.pool->size);
|
|
cmd(c, CSbigsz, c->bg.pool->size);
|
|
- c->bg.lanai = (u32int*)(c->ram + cmd(c, CGbigrxoff, 0));
|
|
|
|
|
|
+ c->bg.lanai = (ulong*)(c->ram + cmd(c, CGbigrxoff, 0));
|
|
c->bg.n = entries;
|
|
c->bg.n = entries;
|
|
c->bg.m = entries-1;
|
|
c->bg.m = entries-1;
|
|
c->bg.host = emalign(entries * sizeof *c->bg.host);
|
|
c->bg.host = emalign(entries * sizeof *c->bg.host);
|
|
@@ -1021,7 +1021,7 @@ static Block*
|
|
nextblock(Ctlr *c)
|
|
nextblock(Ctlr *c)
|
|
{
|
|
{
|
|
uint i;
|
|
uint i;
|
|
- u16int l, k;
|
|
|
|
|
|
+ ushort l, k;
|
|
Block *b;
|
|
Block *b;
|
|
Done *d;
|
|
Done *d;
|
|
Rx *rx;
|
|
Rx *rx;
|
|
@@ -1099,7 +1099,7 @@ m10rx(void *v)
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
static void
|
|
-txcleanup(Tx *tx, u32int n)
|
|
|
|
|
|
+txcleanup(Tx *tx, ulong n)
|
|
{
|
|
{
|
|
Block *b;
|
|
Block *b;
|
|
uint j, l, m;
|
|
uint j, l, m;
|
|
@@ -1124,7 +1124,7 @@ txcleanup(Tx *tx, u32int n)
|
|
if(tx->cnt == tx->i)
|
|
if(tx->cnt == tx->i)
|
|
return;
|
|
return;
|
|
if(l++ == m){
|
|
if(l++ == m){
|
|
- iprint("tx ovrun: %ud %uld\n", n, tx->npkt);
|
|
|
|
|
|
+ iprint("tx ovrun: %lud %lud\n", n, tx->npkt);
|
|
return;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -1195,8 +1195,8 @@ nsegments(Block *b, int segsz)
|
|
static void
|
|
static void
|
|
m10gtransmit(Ether *e)
|
|
m10gtransmit(Ether *e)
|
|
{
|
|
{
|
|
- u16int slen;
|
|
|
|
- u32int i, cnt, rdma, nseg, count, end, bus, len, segsz;
|
|
|
|
|
|
+ ushort slen;
|
|
|
|
+ ulong i, cnt, rdma, nseg, count, end, bus, len, segsz;
|
|
uchar flags;
|
|
uchar flags;
|
|
Block *b;
|
|
Block *b;
|
|
Ctlr *c;
|
|
Ctlr *c;
|
|
@@ -1254,7 +1254,7 @@ m10gtransmit(Ether *e)
|
|
static void
|
|
static void
|
|
checkstats(Ether *e, Ctlr *c, Stats *s)
|
|
checkstats(Ether *e, Ctlr *c, Stats *s)
|
|
{
|
|
{
|
|
- u32int i;
|
|
|
|
|
|
+ ulong i;
|
|
|
|
|
|
if(s->updated == 0)
|
|
if(s->updated == 0)
|
|
return;
|
|
return;
|
|
@@ -1269,7 +1269,7 @@ checkstats(Ether *e, Ctlr *c, Stats *s)
|
|
}
|
|
}
|
|
i = gbit32(s->nrdma);
|
|
i = gbit32(s->nrdma);
|
|
if(i != c->nrdma){
|
|
if(i != c->nrdma){
|
|
- dprint("m10g: rdma timeout %d\n", i);
|
|
|
|
|
|
+ dprint("m10g: rdma timeout %ld\n", i);
|
|
c->nrdma = i;
|
|
c->nrdma = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -1383,18 +1383,18 @@ m10gifstat(Ether *e, void *v, long n, ulong off)
|
|
|
|
|
|
// l +=
|
|
// l +=
|
|
snprint(p+l, lim,
|
|
snprint(p+l, lim,
|
|
- "txcnt = %ud\n" "linkstat = %ud\n" "dlink = %ud\n"
|
|
|
|
- "derror = %ud\n" "drunt = %ud\n" "doverrun = %ud\n"
|
|
|
|
- "dnosm = %ud\n" "dnobg = %ud\n" "nrdma = %ud\n"
|
|
|
|
|
|
+ "txcnt = %lud\n" "linkstat = %lud\n" "dlink = %lud\n"
|
|
|
|
+ "derror = %lud\n" "drunt = %lud\n" "doverrun = %lud\n"
|
|
|
|
+ "dnosm = %lud\n" "dnobg = %lud\n" "nrdma = %lud\n"
|
|
"txstopped = %ud\n" "down = %ud\n" "updated = %ud\n"
|
|
"txstopped = %ud\n" "down = %ud\n" "updated = %ud\n"
|
|
"valid = %ud\n\n"
|
|
"valid = %ud\n\n"
|
|
- "tx pkt = %uld\n" "tx bytes = %lld\n"
|
|
|
|
|
|
+ "tx pkt = %lud\n" "tx bytes = %lld\n"
|
|
"tx cnt = %ud\n" "tx n = %ud\n" "tx i = %ud\n"
|
|
"tx cnt = %ud\n" "tx n = %ud\n" "tx i = %ud\n"
|
|
"sm cnt = %ud\n" "sm i = %ud\n" "sm n = %ud\n"
|
|
"sm cnt = %ud\n" "sm i = %ud\n" "sm n = %ud\n"
|
|
"sm lst = %ud\n"
|
|
"sm lst = %ud\n"
|
|
"bg cnt = %ud\n" "bg i = %ud\n" "bg n = %ud\n"
|
|
"bg cnt = %ud\n" "bg i = %ud\n" "bg n = %ud\n"
|
|
"bg lst = %ud\n"
|
|
"bg lst = %ud\n"
|
|
- "segsz = %ud\n" "coal = %d\n",
|
|
|
|
|
|
+ "segsz = %lud\n" "coal = %lud\n",
|
|
gbit32(s.txcnt), gbit32(s.linkstat), gbit32(s.dlink),
|
|
gbit32(s.txcnt), gbit32(s.linkstat), gbit32(s.dlink),
|
|
gbit32(s.derror), gbit32(s.drunt), gbit32(s.doverrun),
|
|
gbit32(s.derror), gbit32(s.drunt), gbit32(s.doverrun),
|
|
gbit32(s.dnosm), gbit32(s.dnobg), gbit32(s.nrdma),
|
|
gbit32(s.dnosm), gbit32(s.dnobg), gbit32(s.nrdma),
|