int skge_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs)
{
const u32 *r = (const u32 *) regs->data;
int dual = !(regs->data[0x11a] & 1);
dump_pci(regs->data + 0x380);
dump_control(regs->data);
printf("\nBus Management Unit\n");
printf("-------------------\n");
printf("CSR Receive Queue 1 0x%08X\n", r[24]);
printf("CSR Sync Queue 1 0x%08X\n", r[26]);
printf("CSR Async Queue 1 0x%08X\n", r[27]);
if (dual) {
printf("CSR Receive Queue 2 0x%08X\n", r[25]);
printf("CSR Async Queue 2 0x%08X\n", r[29]);
printf("CSR Sync Queue 2 0x%08X\n", r[28]);
}
dump_mac(regs->data);
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_timer("Timer", regs->data + 0x130);
dump_timer("Blink Source", regs->data +0x170);
dump_queue("Receive Queue 1", regs->data +0x400, 1);
dump_queue("Sync Transmit Queue 1", regs->data +0x600, 0);
dump_queue("Async Transmit Queue 1", regs->data +0x680, 0);
dump_ram("Receive RAMbuffer 1", regs->data+0x800);
dump_ram("Sync Transmit RAMbuffer 1", regs->data+0xa00);
dump_ram("Async Transmit RAMbuffer 1", regs->data+0xa80);
dump_fifo("Receive MAC FIFO 1", regs->data+0xc00);
dump_fifo("Transmit MAC FIFO 1", regs->data+0xd00);
if (dual) {
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_queue("Receive Queue 2", regs->data +0x480, 1);
dump_queue("Async Transmit Queue 2", regs->data +0x780, 0);
dump_queue("Sync Transmit Queue 2", regs->data +0x700, 0);
dump_ram("Receive RAMbuffer 2", regs->data+0x880);
dump_ram("Sync Transmit RAMbuffer 2", regs->data+0xb00);
dump_ram("Async Transmit RAMbuffer 21", regs->data+0xb80);
dump_fifo("Receive MAC FIFO 2", regs->data+0xc80);
dump_fifo("Transmit MAC FIFO 2", regs->data+0xd80);
}
dump_timer("Descriptor Poll", regs->data+0xe00);
return 0;
}
int
send_control_frame(int fd, LaneControl_t *to_send)
{
int a;
Debug_unit(&conn_unit,"Send control frame");
dump_control(to_send);
a = write(fd, to_send, sizeof(LaneControl_t));
if (a == -1) {
dump_error(&conn_unit,"Write error");
return 0;
}
return 1;
}
/*
*****************************************************************************
* Function : dump_dialogex
* Syntax : void dump_dialogex(const dialogex_t *dlgex)
* Input :
* dlgex - DialogEx resource descriptor
* Output :
* Description :
* Remarks :
*****************************************************************************
*/
static void dump_dialogex(const dialogex_t *dlgex)
{
const control_t *c = dlgex->controls;
dump_memopt(dlgex->memopt);
dump_lvc(&(dlgex->lvc));
printf("x, y, w, h: %d, %d, %d, %d\n", dlgex->x, dlgex->y, dlgex->width, dlgex->height);
if(dlgex->gotstyle)
{
assert(dlgex->style != NULL);
assert(dlgex->style->and_mask == 0);
printf("Style: %08lx\n", dlgex->style->or_mask);
}
if(dlgex->gotexstyle)
{
assert(dlgex->exstyle != NULL);
assert(dlgex->exstyle->and_mask == 0);
printf("ExStyle: %08lx\n", dlgex->exstyle->or_mask);
}
if(dlgex->gothelpid)
printf("Helpid: %ld\n", dlgex->helpid);
printf("Menu: %s\n", get_nameid_str(dlgex->menu));
printf("Class: %s\n", get_nameid_str(dlgex->dlgclass));
printf("Title: ");
print_string(dlgex->title);
printf("\n");
printf("Font: ");
if(!dlgex->font)
printf("<none>\n");
else
{
printf("%d, ", dlgex->font->size);
print_string(dlgex->font->name);
printf(", %d, %d\n", dlgex->font->weight, dlgex->font->italic);
}
while(c)
{
dump_control(c);
c = c->next;
}
}
static struct nsctl *request(char *host, int port, int type, int argc, char *argv[])
{
static struct nsctl res;
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
struct hostent *h = gethostbyname(host);
int fd;
uint8_t buf[NSCTL_MAX_PKT_SZ];
int sz;
char *err;
if (!h || h->h_addrtype != AF_INET)
{
fprintf(stderr, "%s: invalid host `%s'\n", me, host);
return 0;
}
if ((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
{
fprintf(stderr, "%s: can't create udp socket (%s)\n", me, strerror(errno));
return 0;
}
memset(&peer, 0, len);
peer.sin_family = AF_INET;
peer.sin_port = htons(port);
memcpy(&peer.sin_addr.s_addr, h->h_addr, sizeof(peer.sin_addr.s_addr));
if (connect(fd, (struct sockaddr *) &peer, sizeof(peer)) < 0)
{
fprintf(stderr, "%s: udp connect failed (%s)\n", me, strerror(errno));
return 0;
}
if ((sz = pack_control(buf, sizeof(buf), type, argc, argv)) < 0)
{
fprintf(stderr, "%s: error packing request\n", me);
return 0;
}
if (debug)
{
struct nsctl req;
if (unpack_control(&req, buf, sz) == type)
{
fprintf(stderr, "Sending ");
dump_control(&req, stderr);
}
}
if (send(fd, buf, sz, 0) < 0)
{
fprintf(stderr, "%s: error sending request (%s)\n", me, strerror(errno));
return 0;
}
/* set timer */
if (timeout)
{
struct sigaction alrm;
alrm.sa_handler = sigalrm_handler;
sigemptyset(&alrm.sa_mask);
alrm.sa_flags = 0;
sigaction(SIGALRM, &alrm, 0);
alarm(timeout);
}
sz = recv(fd, buf, sizeof(buf), 0);
alarm(0);
if (sz < 0)
{
fprintf(stderr, "%s: error receiving response (%s)\n", me,
errno == EINTR ? "timed out" : strerror(errno));
return 0;
}
if ((type = unpack_control(&res, buf, sz)) > 0 && type & NSCTL_RESPONSE)
{
if (debug)
{
fprintf(stderr, "Received ");
dump_control(&res, stderr);
}
return &res;
}
err = "unknown error";
switch (type)
{
case NSCTL_ERR_SHORT:
err = "short packet";
break;
case NSCTL_ERR_LONG:
err = "extra data";
break;
case NSCTL_ERR_MAGIC:
err = "bad magic";
break;
case NSCTL_ERR_TYPE:
err = "invalid type";
break;
}
fprintf(stderr, "%s: %s\n", me, err);
return 0;
}
/*
* Handle new connections or data arrival
* data points to Conn_t
*/
static int
data_handler(const Event_t *event, void *funcdata)
{
Conn_t *tmp, *newconn;
int fd, nbytes;
static char buffer[BUFSIZE];
LaneControl_t *ctmp;
struct sockaddr_atmsvc addr;
assert(event->data != NULL);
tmp = (Conn_t *)event->data;
dump_conn(tmp);
if (tmp->type == CT_MAIN) {
nbytes = sizeof(addr);
memset(&addr,0, nbytes);
fd = accept(tmp->fd, (struct sockaddr *)&addr, &nbytes);
if (fd <0) {
dump_error(&conn_unit, "accept");
if (errno == ENETRESET) {
Debug_unit(&conn_unit,"Restart. Sleeping 10 secs...");
sleep(10);
event_put(&conn_unit, CE_RESTART, NULL);
} else if (errno == EUNATCH) {
Debug_unit(&conn_unit,"Exiting...");
event_put(&conn_unit, CE_EXIT, NULL);
}
return -1;
}
newconn = conn_add(CT_SVC_CD, fd,0);
newconn->state = call_state(CE_SVC_OPEN, 0, newconn);
}
else {
/* tmp->fd or tmp->sfd ?*/
nbytes = read(tmp->active_fd, buffer, BUFSIZE);
if (nbytes < 0) {
dump_error(&conn_unit, "read");
if (errno == EUNATCH)
event_put(&conn_unit, CE_EXIT, NULL);
if (errno == ENETRESET) {
Debug_unit(&conn_unit, "Restart. Sleeping 10 secs...");
sleep(10);
event_put(&conn_unit, CE_RESTART, NULL);
}
} else if (nbytes == 0) {
/* EOF */
Debug_unit(&conn_unit, "EOF");
tmp->state = call_state(CE_SVC_CLOSE, 0, tmp);
} else {
buffer[nbytes] = '\0';
Debug_unit(&conn_unit, "Data: %2.2x %2.2x %2.2x",
0xff&buffer[0],0xff&buffer[1],0xff&buffer[2]);
ctmp = (LaneControl_t *)buffer;
if (is_control(ctmp) == 1) {
control_packet = (LaneControl_t*)buffer;
dump_control(ctmp);
tmp->proxy = is_proxy();
tmp->state = call_state(CE_DATA, ctmp->opcode, tmp);
} else
Debug_unit(&conn_unit,"Not a control_packet, discarding...");
}
}
mem_free(&conn_unit, event);
return 1;
}
int sky2_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs)
{
const u16 *r16 = (const u16 *) regs->data;
const u32 *r32 = (const u32 *) regs->data;
int dual;
dump_pci(regs->data + 0x1c00);
dump_control(regs->data);
printf("\nBus Management Unit\n");
printf("-------------------\n");
printf("CSR Receive Queue 1 0x%08X\n", r32[24]);
printf("CSR Sync Queue 1 0x%08X\n", r32[26]);
printf("CSR Async Queue 1 0x%08X\n", r32[27]);
dual = (regs->data[0x11e] & 2) != 0;
if (dual) {
printf("CSR Receive Queue 2 0x%08X\n", r32[25]);
printf("CSR Async Queue 2 0x%08X\n", r32[29]);
printf("CSR Sync Queue 2 0x%08X\n", r32[28]);
}
dump_mac(regs->data);
dump_prefetch("Status", regs->data + 0xe80);
dump_prefetch("Receive 1", regs->data + 0x450);
dump_prefetch("Transmit 1", regs->data + 0x450 + 0x280);
if (dual) {
dump_prefetch("Receive 2", regs->data + 0x450 + 0x80);
dump_prefetch("Transmit 2", regs->data + 0x450 + 0x380);
}
printf("\nStatus FIFO\n");
printf("\tWrite Pointer 0x%02X\n", regs->data[0xea0]);
printf("\tRead Pointer 0x%02X\n", regs->data[0xea4]);
printf("\tLevel 0x%02X\n", regs->data[0xea8]);
printf("\tWatermark 0x%02X\n", regs->data[0xeac]);
printf("\tISR Watermark 0x%02X\n", regs->data[0xead]);
dump_timer("Status level", regs->data + 0xeb0);
dump_timer("TX status", regs->data + 0xec0);
dump_timer("ISR", regs->data + 0xed0);
printf("\nGMAC control 0x%04X\n", r32[0xf00 >> 2]);
printf("GPHY control 0x%04X\n", r32[0xf04 >> 2]);
printf("LINK control 0x%02hX\n", r16[0xf10 >> 1]);
dump_gmac("GMAC 1", regs->data + 0x2800);
dump_gmac_fifo("Rx GMAC 1", regs->data + 0xc40);
dump_gmac_fifo("Tx GMAC 1", regs->data + 0xd40);
dump_queue2("Receive Queue 1", regs->data +0x400, 1);
dump_queue("Sync Transmit Queue 1", regs->data +0x600, 0);
dump_queue2("Async Transmit Queue 1", regs->data +0x680, 0);
dump_ram("Receive RAMbuffer 1", regs->data+0x800);
dump_ram("Sync Transmit RAMbuffer 1", regs->data+0xa00);
dump_ram("Async Transmit RAMbuffer 1", regs->data+0xa80);
if (dual) {
dump_ram("Receive RAMbuffer 2", regs->data+0x880);
dump_ram("Sync Transmit RAMbuffer 2", regs->data+0xb00);
dump_ram("Async Transmit RAMbuffer 21", regs->data+0xb80);
dump_gmac("GMAC 2", regs->data + 0x3800);
dump_gmac_fifo("Rx GMAC 2", regs->data + 0xc40 + 128);
dump_gmac_fifo("Tx GMAC 2", regs->data + 0xd40 + 128);
}
return 0;
}
