static void
dumpsym (const rpc_sym *s)
{
switch (s->type) {
case rpc_sym::CONST:
aout << "enum { " << s->sconst->id
<< " = " << s->sconst->val << " };\n";
break;
case rpc_sym::STRUCT:
dumpstruct (s);
break;
case rpc_sym::UNION:
dumpunion (s);
break;
case rpc_sym::ENUM:
dumpenum (s);
break;
case rpc_sym::TYPEDEF:
dumptypedef (s);
break;
case rpc_sym::PROGRAM:
dumpprog (s->sprogram);
break;
case rpc_sym::NAMESPACE:
dumpnamespace (s);
break;
case rpc_sym::LITERAL:
aout << *s->sliteral << "\n";
break;
default:
break;
}
}
int spec_i2c_init(struct fmc_device *fmc)
{
struct spec_dev *spec = fmc->carrier_data;
void *buf;
int i, found;
found = mi2c_scan(fmc);
if (!found) {
fmc->flags |= FMC_DEVICE_NO_MEZZANINE;
return 0;
}
buf = kmalloc(SPEC_I2C_EEPROM_SIZE, GFP_KERNEL);
if (!buf)
return -ENOMEM;
i = spec_eeprom_read(fmc, SPEC_I2C_EEPROM_ADDR, 0, buf,
SPEC_I2C_EEPROM_SIZE);
if (i != SPEC_I2C_EEPROM_SIZE) {
dev_err(&spec->pdev->dev, "EEPROM read error: retval is %i\n",
i);
kfree(buf);
return -EIO;
}
fmc->eeprom = buf;
fmc->eeprom_len = SPEC_I2C_EEPROM_SIZE;
if (spec_i2c_dump)
dumpstruct("eeprom", buf, SPEC_I2C_EEPROM_SIZE);
return 0;
}
/* TLV dumper, not yet white-rabbit aware */
static int dump_tlv(char *prefix, struct ptp_tlv *tlv, int totallen)
{
/* the field includes 6 bytes of the header, ecludes 4 of them. Bah! */
int explen = ntohs(tlv->len) + 4;
printf("%sTLV: type %04x len %i oui %02x:%02x:%02x "
"sub %02x:%02x:%02x\n", prefix, ntohs(tlv->type), explen,
tlv->oui[0], tlv->oui[1], tlv->oui[2],
tlv->subtype[0], tlv->subtype[1], tlv->subtype[2]);
if (explen > totallen) {
printf("%sTLV: too short (expected %i, total %i)\n", prefix,
explen, totallen);
return totallen;
}
/* later: if (memcmp(tlv->oui, "\x08\x00\x30", 3)) ... */
/* Now dump non-wr tlv in binary, count only payload */
dumpstruct(prefix, "TLV: ", "tlv-content", tlv->data,
explen - sizeof(*tlv));
return explen;
}
/* A big function to dump the ptp information */
static void dump_payload(char *prefix, void *pl, int len)
{
struct ptp_header *h = pl;
void *msg_specific = (void *)(h + 1);
int donelen = 34; /* packet length before tlv */
int version = h->versionPTP_and_reserved & 0xf;
int messageType = h->type_and_transport_specific & 0xf;
if (version != 2) {
printf("%sVERSION: unsupported (%i)\n", prefix, version);
return;
}
printf("%sVERSION: %i (type %i, len %i, domain %i)\n", prefix,
version, messageType,
ntohs(h->messageLength), h->domainNumber);
printf("%sFLAGS: 0x%04x (correction %08lu)\n", prefix, h->flagField,
(unsigned long)h->correctionField);
dump_1port(prefix, "PORT: ", h->sourcePortIdentity);
printf("%sREST: seq %i, ctrl %i, log-interval %i\n", prefix,
ntohs(h->sequenceId), h->controlField, h->logMessageInterval);
#define CASE(t, x) case PPM_ ##x: printf("%sMESSAGE: (" #t ") " #x "\n", prefix)
switch(messageType) {
CASE(E, SYNC);
dump_msg_sync_etc(prefix, "MSG-SYNC: ", msg_specific);
donelen = 44;
break;
CASE(E, DELAY_REQ);
dump_msg_sync_etc(prefix, "MSG-DELAY_REQ: ", msg_specific);
donelen = 44;
break;
CASE(G, FOLLOW_UP);
dump_msg_sync_etc(prefix, "MSG-FOLLOW_UP: ", msg_specific);
donelen = 44;
break;
CASE(G, DELAY_RESP);
dump_msg_resp_etc(prefix, "MSG-DELAY_RESP: ", msg_specific);
donelen = 54;
break;
CASE(G, ANNOUNCE);
dump_msg_announce(prefix, msg_specific);
donelen = 64;
break;
CASE(G, SIGNALING);
dump_1port(prefix, "MSG-SIGNALING: target-port ", msg_specific);
donelen = 44;
break;
#if __STDC_HOSTED__ /* Avoid pdelay dump withing ppsi, we don't use it */
CASE(E, PDELAY_REQ);
dump_msg_sync_etc(prefix, "MSG-PDELAY_REQ: ", msg_specific);
donelen = 54;
break;
CASE(E, PDELAY_RESP);
dump_msg_resp_etc(prefix, "MSG-PDELAY_RESP: ", msg_specific);
donelen = 54;
break;
CASE(G, PDELAY_RESP_FOLLOW_UP);
dump_msg_resp_etc(prefix, "MSG-PDELAY_RESP_FOLLOWUP: ",
msg_specific);
donelen = 54;
break;
CASE(G, MANAGEMENT);
/* FIXME */
break;
#endif
}
/*
* Dump any trailing TLV, but ignore a trailing 2-long data hunk.
* The trailing zeroes appear with less-than-minimum Eth messages.
*/
while (donelen < len && len - donelen > 2) {
int n = len - donelen;
if (n < sizeof(struct ptp_tlv)) {
printf("%sTLV: too short (%i - %i = %i)\n", prefix,
len, donelen, n);
break;
}
donelen += dump_tlv(prefix, pl + donelen, n);
}
/* Finally, binary dump of it all */
dumpstruct(prefix, "DUMP: ", "payload", pl, len);
}
