signed PHYSettings (struct channel * channel, struct phy_settings * settings, flag_t flags)
{
struct message message;
signed packetsize;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_enet_settings_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MCONTROL;
uint8_t AUTONEGOTIATE;
uint8_t ADVCAPS;
uint8_t ESPEED;
uint8_t EDUPLEX;
uint8_t EFLOWCONTROL;
}
* request = (struct vs_enet_settings_request *) (&message);
struct __packed vs_enet_settings_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t ESPEED;
uint8_t EDUPLEX;
uint8_t ELINKSTATUS;
uint8_t EFLOWCONTROL;
}
* confirm = (struct vs_enet_settings_confirm *) (&message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
char address [ETHER_ADDR_LEN * 3];
memset (&message, 0, sizeof (message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_ENET_SETTINGS | MMTYPE_REQ));
request->MCONTROL = settings->MCONTROL;
request->AUTONEGOTIATE = settings->AUTONEGOTIATE;
request->ADVCAPS = settings->ADVCAPS;
request->ESPEED = settings->ESPEED;
request->EDUPLEX = settings->EDUPLEX;
request->EFLOWCONTROL = settings->EFLOWCONTROL;
if (sendpacket (channel, &message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) < 0)
{
error (1, errno, CHANNEL_CANTSEND);
}
while ((packetsize = readpacket (channel, &message, sizeof (message))) > 0)
{
if (UnwantedMessage (&message, packetsize, 0, (VS_ENET_SETTINGS | MMTYPE_CNF)))
{
continue;
}
if ((confirm->MSTATUS == 1) || (confirm->MSTATUS == 3))
{
error (0, 0, "%s: %s (0x%0X): ", PLC_WONTDOIT, MMECode (confirm->qualcomm.MMTYPE, confirm->MSTATUS), confirm->MSTATUS);
continue;
}
if (_anyset (flags, PLC_ANALYSE))
{
printf ("Bits Mode Link Flow\n");
printf ("%4d ", confirm->ESPEED);
printf ("%4d ", confirm->EDUPLEX);
printf ("%4d ", confirm->ELINKSTATUS);
printf ("%4d\n", confirm->EFLOWCONTROL);
}
else
{
printf ("%s %s ", channel->ifname, hexstring (address, sizeof (address), channel->host, sizeof (channel->host)));
printf ("Speed=%s ", rates [confirm->ESPEED]);
printf ("Duplex=%s ", modes [confirm->EDUPLEX]);
printf ("LinkStatus=%s ", links [confirm->ELINKSTATUS]);
printf ("FlowControl=%s\n", flows [confirm->EFLOWCONTROL]);
}
}
if (packetsize < 0)
{
error (1, errno, CHANNEL_CANTREAD);
}
return (0);
}
static signed mdio (struct channel * channel, uint8_t mode, uint8_t phy, uint8_t reg, uint16_t * data)
{
struct message message;
signed packetsize;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_mdio_command_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t OPERATION;
uint8_t PHY;
uint8_t REG;
uint16_t DATA;
}
* request = (struct vs_mdio_command_request *)(&message);
struct __packed vs_mdio_command_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint16_t DATA;
uint8_t PHY;
uint8_t REG;
}
* confirm = (struct vs_mdio_command_confirm *)(&message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
memset (&message, 0, sizeof (message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_MDIO_COMMAND | MMTYPE_REQ));
request->OPERATION = mode;
request->PHY = phy;
request->REG = reg;
request->DATA = HTOLE16 (*data);
#if 1
printf (" phy 0x%02X", phy);
printf (" reg 0x%02X", reg);
printf (" data 0x%04X", * data);
printf ("\n");
#endif
if (sendpacket (channel, &message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) == -1)
{
error (1, errno, CHANNEL_CANTSEND);
}
while ((packetsize = readpacket (channel, &message, sizeof (message))) > 0)
{
if (UnwantedMessage (&message, packetsize, 0, (VS_MDIO_COMMAND | MMTYPE_CNF)))
{
continue;
}
if (confirm->MSTATUS)
{
error (0, 0, "%s (%0X): %s", MMECode (confirm->qualcomm.MMTYPE, confirm->MSTATUS), confirm->MSTATUS, PLC_WONTDOIT);
continue;
}
*data = confirm->DATA;
return (0);
}
return (-1);
}
static void ReadKey1 (struct channel * channel, unsigned c, int key)
{
struct message message;
static signed count = 0;
signed packetsize;
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_rd_mod_request
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MODULEID;
uint8_t RESERVED;
uint16_t MLENGTH;
uint32_t MOFFSET;
uint8_t DAK [16];
}
* request = (struct vs_rd_mod_request *)(&message);
struct __packed vs_rd_mod_confirm
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
uint8_t RESERVED1 [3];
uint8_t MODULEID;
uint8_t RESERVED2;
uint16_t MLENGTH;
uint32_t MOFFSET;
uint32_t MCHKSUM;
struct simple_pib pib;
}
* confirm = (struct vs_rd_mod_confirm *)(&message);
#ifndef __GNUC__
#pragma pack (pop)
#endif
memset (&message, 0, sizeof (message));
EthernetHeader (&request->ethernet, channel->peer, channel->host, channel->type);
QualcommHeader (&request->qualcomm, 0, (VS_RD_MOD | MMTYPE_REQ));
request->MODULEID = VS_MODULE_PIB;
request->MLENGTH = HTOLE16 (PLC_RECORD_SIZE);
request->MOFFSET = HTOLE32 (0);
if (sendpacket (channel, &message, (ETHER_MIN_LEN - ETHER_CRC_LEN)) < 0)
{
error (1, errno, CHANNEL_CANTSEND);
}
while ((packetsize = readpacket (channel, &message, sizeof (message))) > 0)
{
if (UnwantedMessage (&message, packetsize, 0, (VS_RD_MOD | MMTYPE_CNF)))
{
continue;
}
if (confirm->MSTATUS)
{
error (0, 0, "%s (%0X): ", MMECode (confirm->qualcomm.MMTYPE, confirm->MSTATUS), confirm->MSTATUS);
continue;
}
if (count++ > 0)
{
putc (c, stdout);
}
if (key == INT6KID_MAC)
{
hexout (confirm->pib.MAC, sizeof (confirm->pib.MAC), HEX_EXTENDER, 0, stdout);
continue;
}
if (key == INT6KID_DAK)
{
hexout (confirm->pib.DAK, sizeof (confirm->pib.DAK), HEX_EXTENDER, 0, stdout);
continue;
}
if (key == INT6KID_NMK)
{
hexout (confirm->pib.NMK, sizeof (confirm->pib.NMK), HEX_EXTENDER, 0, stdout);
continue;
}
if (key == INT6KID_MFG)
{
confirm->pib.MFG [PIB_HFID_LEN - 1] = (char)(0);
printf ("%s", confirm->pib.MFG);
continue;
}
if (key == INT6KID_USR)
{
confirm->pib.USR [PIB_HFID_LEN - 1] = (char)(0);
printf ("%s", confirm->pib.USR);
continue;
}
if (key == INT6KID_NET)
{
confirm->pib.NET [PIB_HFID_LEN - 1] = (char)(0);
printf ("%s", confirm->pib.NET);
continue;
}
}
if (packetsize < 0)
{
error (1, errno, CHANNEL_CANTREAD);
}
return;
}
