static void NetReceive(u8 *inpkt, int len)
{
struct racfghdr *p_racfgh = NULL;
unsigned char *p_tmp = inpkt;
u16 Command_Type;
p_racfgh = (struct racfghdr *) inpkt;
ate_printf(MSG_INFO, "Receive Packet\n");
if (be2cpu32/*ntohl*/(p_racfgh->magic_no) == RACFG_MAGIC_NO) {
p_tmp = p_tmp + OFFSET_OF(struct racfghdr, comand_type);
os_memcpy(&Command_Type, p_tmp, sizeof(Command_Type));
Command_Type = be2cpu16(Command_Type);
if ((Command_Type & RACFG_CMD_TYPE_PASSIVE_MASK) != RACFG_CMD_TYPE_ETHREQ) {
ate_printf(MSG_ERROR, "Command_Type error = %x\n", Command_Type);
return;
}
task_dispatcher(inpkt,len,0);
} else if(be2cpu32/*ntohl*/(p_racfgh->magic_no) == NEW_MAGIC_NO){
void init_dump(struct pcidev *dev, char *filename)
{
FILE *fd;
uint32_t eeprom_size;
int d;
seteuid(ruid);
if (!(fd = fopen(filename, "rb")))
die("Can't read file '%s'\n", filename);
eeprom_size = 2 * fread(buf, 2, EEPROM_SIZE_MAX/2, fd);
fclose(fd);
seteuid(suid);
for(d=0; !dev->ops && iodrivers[d]; d++) {
if (dev->forced_driver) {
if(!strcmp(dev->forced_driver, iodrivers[d]->name)) {
dev->ops = iodrivers[d];
}
} else {
if ( iodrivers[d]->eeprom_signature == le2cpu16(*(uint16_t*)buf)) {
dump_order = order_le;
dev->ops = iodrivers[d];
} else if ( iodrivers[d]->eeprom_signature == be2cpu16(*(uint16_t*)buf)) {
dump_order = order_be;
dev->ops = iodrivers[d];
}
}
}
if (!dev->ops)
die("No usable IO driver found for this dump!\n");
printf(" Using IO driver%s: %s\n", dev->forced_driver ? " (forced)":"" ,dev->ops->name);
dev->ops->eeprom_size = eeprom_size;
dev->ops->eeprom_read16 = &buf_read16;
dev->ops->eeprom_write16 = &buf_write16;
printf(" byte order: %s ENDIAN\n", (dump_order == order_le) ? "LITTLE":"BIG");
}
SANE_Status
get_adjust_data (struct scanner * s, unsigned *dummy_length)
{
SANE_Status status;
struct cmd c = {
{0},
10,
0,
40,
CMD_IN
};
u16 *data;
c.cmd[0] = GET_ADJUST_DATA;
c.cmd[2] = 0x9b;
c.cmd[8] = 40;
status = send_command (s, &c);
if (status)
return status;
data = (u16 *) c.data;
*dummy_length = be2cpu16 (data[0]);
return SANE_STATUS_GOOD;
}
static BOOLEAN NfcProcessPasswdTV(
IN PRTMP_ADAPTER pAdapter,
IN PUCHAR pPlainData,
IN INT PlainLength,
IN PWSC_CTRL pWscCtrl,
IN UCHAR bHandOver)
{
USHORT WscType, WscLen;
PUCHAR pData;
INT DH_Len = 0, idx;
pData = pPlainData;
hex_dump("NfcProcessPasswdTV - PlainData", pPlainData, PlainLength);
// Start to process WSC IEs within credential
if (bHandOver)
{
pData +=2; /* Skip length of WSC attribute */
PlainLength -= 2;
}
while (PlainLength > 4)
{
WSC_IE TLV_Recv;
memcpy((UINT8 *)&TLV_Recv, pData, 4);
WscType = be2cpu16(TLV_Recv.Type);
WscLen = be2cpu16(TLV_Recv.Length);
pData += 4;
PlainLength -= 4;
// Parse M2 WSC type and store to RegData structure
switch (WscType)
{
case WSC_ID_OOB_DEV_PWD:
hex_dump("NfcProcessPasswdTV - WSC_ID_OOB_DEV_PWD", pData, WscLen);
NdisMoveMemory(&pWscCtrl->PeerNfcPasswdHash[0], pData, NFC_DEV_PASSWD_HASH_LEN);
NdisMoveMemory(&pWscCtrl->PeerNfcPasswdID, pData+20, sizeof(pWscCtrl->PeerNfcPasswdID));
pWscCtrl->PeerNfcPasswdLen = WscLen - 2 - NFC_DEV_PASSWD_HASH_LEN;
if (pWscCtrl->PeerNfcPasswdLen > NFC_DEV_PASSWD_LEN)
{
DBGPRINT(RT_DEBUG_TRACE, ("%s --> PeerNfcPasswdLen(%d) > NFC_DEV_PASSWD_LEN(%d)\n",
__FUNCTION__, pWscCtrl->PeerNfcPasswdLen, NFC_DEV_PASSWD_LEN));
pWscCtrl->PeerNfcPasswdLen = NFC_DEV_PASSWD_LEN;
}
if (bHandOver== TRUE)
{
if (pWscCtrl->PeerNfcPasswdID != DEV_PASS_ID_NFC_HANDOVER)
DBGPRINT(RT_DEBUG_TRACE, ("%s --> PeerNfcPasswdID(%04x) it should 0x0007 \n",
__FUNCTION__, pWscCtrl->PeerNfcPasswdID));
}
NdisMoveMemory(&pWscCtrl->PeerNfcPasswd[0], pData+20+sizeof(pWscCtrl->PeerNfcPasswdID), pWscCtrl->PeerNfcPasswdLen);
hex_dump("PeerNfcPasswd", pWscCtrl->PeerNfcPasswd, pWscCtrl->PeerNfcPasswdLen);
if (bHandOver==FALSE)
{
/* Due to M3 & M4 use the same WscGenPSK1 function,
need copy to NfcPasswd, too */
NdisMoveMemory(&pWscCtrl->NfcPasswd[0], &pWscCtrl->PeerNfcPasswd[0], pWscCtrl->PeerNfcPasswdLen);
pWscCtrl->NfcPasswdLen = pWscCtrl->PeerNfcPasswdLen;
}
break;
case WSC_ID_UUID_E:
NdisMoveMemory(pWscCtrl->RegData.PeerInfo.Uuid, pData, WscLen);
break;
case WSC_ID_SSID:
hex_dump("NfcProcessPasswdTV - WSC_ID_SSID", pData, WscLen);
break;
case WSC_ID_VENDOR_EXT:
hex_dump("NfcProcessPasswdTV - WSC_ID_VENDOR_EXT", pData, WscLen);
break;
default:
DBGPRINT(RT_DEBUG_TRACE, ("%s --> Unknown IE 0x%04x\n", __FUNCTION__, WscType));
break;
}
// Offset to net WSC Ie
pData += WscLen;
PlainLength -= WscLen;
}
DBGPRINT(RT_DEBUG_TRACE, ("%s --> bHandOver=%d", __FUNCTION__, bHandOver));
if (bHandOver== FALSE)
{
DH_Len = sizeof(pWscCtrl->RegData.Pkr);
// Enrollee 192 random bytes for DH key generation
for (idx = 0; idx < 192; idx++)
pWscCtrl->RegData.EnrolleeRandom[idx] = RandomByte(pAdapter);
RT_DH_PublicKey_Generate (
WPS_DH_G_VALUE, sizeof(WPS_DH_G_VALUE),
WPS_DH_P_VALUE, sizeof(WPS_DH_P_VALUE),
pWscCtrl->RegData.EnrolleeRandom, sizeof(pWscCtrl->RegData.EnrolleeRandom),
pWscCtrl->RegData.Pkr, (UINT *) &DH_Len);
hex_dump("Pkr", pWscCtrl->RegData.Pkr, 192);
}
return TRUE;
}
VOID WfdParseSubElmt(
IN PRTMP_ADAPTER pAd,
IN PWFD_ENTRY_INFO pWfdEntryInfo,
IN VOID *Msg,
IN ULONG MsgLen)
{
PWFD_COUPLED_SINK_INFO pSinkInfo;
PWFD_DEVICE_INFO pWfd_info;
WFD_DEVICE_INFO DevInfo;
PP2PEID_STRUCT pWfdEid;
PEID_STRUCT pEid;
PUCHAR pWfdIe = NULL;
ULONG AccuWfdIELen;
ULONG AccuIeLen = 0;
ULONG Length = 0;
ULONG AttriLen;
UCHAR offset;
BOOLEAN bTdlsEntry = FALSE;
DBGPRINT(RT_DEBUG_INFO, ("%s ----->\n", __FUNCTION__));
//QQ TBD, p2p widi need to parse rtsp port!
{
if ((!pAd->StaCfg.WfdCfg.bWfdEnable) || (MsgLen == 0))
return;
}
// hex_dump("WfdParseSubElmt::", Msg, MsgLen);
pEid = (PEID_STRUCT)Msg;
AccuIeLen = pEid->Len + 2;
// printk("MsgLen = %d. AccuIeLen = %d.\n", MsgLen, AccuIeLen);
while ((ULONG)(AccuIeLen) <= MsgLen)
{
if (RTMPEqualMemory(&pEid->Octet[0], WIFIDISPLAY_OUI, 4))
{
/* Get Request content capability */
pWfdIe = pWfdEid = (PP2PEID_STRUCT) &pEid->Octet[4];
AccuWfdIELen = pEid->Len;
// printk("AccuWfdIeLen = %d. EidLen = %04x\n", AccuWfdIELen, pEid->Len);
/* The value of AccuP2PIELen shall reduce the length of OUI (4) */
AccuWfdIELen -= 4;
AttriLen = pWfdEid->Len[1] + (pWfdEid->Len[0] << 8);
Length = 0;
// printk("AttriLen = %d. WfdEid = %d. WfdEidLen = %x %x\n", AttriLen, pWfdEid->Eid, pWfdEid->Len[1], pWfdEid->Len[0]);
pWfdEntryInfo->bWfdClient = TRUE; /* Set the P2P client as the WFD device */
// while (Length <=(Length + 3 + AttriLen) <= AccuWfdIELen)
while (Length <= AccuWfdIELen)
{
// printk(">> Eid = %d.\n", pWfdEid->Eid);
switch (pWfdEid->Eid)
{
case SUBID_WFD_DEVICE_INFO:
{
pWfd_info = &(pWfdEid->Octet[0]);
RTMPMoveMemory(&DevInfo, pWfdIe, sizeof(WFD_DEVICE_INFO));
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_device_info_ie, pWfdEid->Octet, SUBID_WFD_DEVICE_INFO_LEN);
cpu2le16(&DevInfo);
pWfdEntryInfo->wfd_devive_type = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 0) & 0x3);
pWfdEntryInfo->source_coupled = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 2) & 0x1);
pWfdEntryInfo->sink_coupled = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 3) & 0x1);
pWfdEntryInfo->session_avail = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 4) & 0x3);
pWfdEntryInfo->wfd_service_discovery = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 6) & 0x1);
pWfdEntryInfo->wfd_PC = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 7) & 0x1);
pWfdEntryInfo->wfd_CP = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 8) & 0x1);
pWfdEntryInfo->wfd_time_sync = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 9) & 0x1);
pWfdEntryInfo->sink_audio_unsupport = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 10) & 0x1);
pWfdEntryInfo->source_audio_only= ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 11) & 0x1);
pWfdEntryInfo->tdls_persistent_group = ((be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[0]))) >> 12) & 0x1);
pWfdEntryInfo->rtsp_port = be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[2])));
pWfdEntryInfo->max_throughput = be2cpu16(get_unaligned((PUSHORT)(&pWfdEid->Octet[4])));
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_DEVICE_INFO\n", __FUNCTION__));
break;
}
case SUBID_WFD_ASSOCIATED_BSSID:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_associate_bssid_ie, pWfdEid->Octet, SUBID_WFD_ASSOCIATED_BSSID_LEN);
RTMPMoveMemory(&pWfdEntryInfo->assoc_addr, pWfdEid->Octet, MAC_ADDR_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_ASSOCIATED_BSSID\n", __FUNCTION__));
break;
}
case SUBID_WFD_AUDIO_FORMATS:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_audio_format_ie, pWfdEid->Octet, SUBID_WFD_AUDIO_FORMATS_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_AUDIO_FORMATS\n", __FUNCTION__));
break;
}
case SUBID_WFD_VIDEO_FORMATS:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_video_format_ie, pWfdEid->Octet, SUBID_WFD_VIDEO_FORMATS_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_VIDEO_FORMATS\n", __FUNCTION__));
break;
}
case SUBID_WFD_3D_VIDEO_FORMATS:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_3d_video_format_ie, pWfdEid->Octet, SUBID_WFD_3D_VIDEO_FORMATS_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_3D_VIDEO_FORMATS\n", __FUNCTION__));
break;
}
case SUBID_WFD_CONTENT_PROTECTION:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_content_proctection, pWfdEid->Octet, SUBID_WFD_CONTENT_PROTECTION_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_CONTENT_PROTECTION\n", __FUNCTION__));
break;
}
case SUBID_WFD_COUPLED_SINK_INFO:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_couple_sink_info_ie, pWfdEid->Octet, SUBID_WFD_COUPLED_SINK_INFO_LEN);
RTMPMoveMemory(&pWfdEntryInfo->coupled_sink_status, pWfdEid->Octet, SUBID_WFD_COUPLED_SINK_INFO_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_COUPLED_SINK_INFO\n", __FUNCTION__));
break;
}
case SUBID_WFD_EXTENDED_CAP:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_extent_capability_ie, &pWfdEid->Octet, SUBID_WFD_EXTENDED_CAP_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_EXTENDED_CAP\n", __FUNCTION__));
break;
}
case SUBID_WFD_LOCAL_IP_ADDR:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_local_ip_ie, &pWfdEid->Octet, SUBID_WFD_LOCAL_IP_ADDR_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_LOCAL_IP_ADDR\n", __FUNCTION__));
break;
}
case SUBID_WFD_SESSION_INFO:
{
/* TODO : allocate memory to store the parsed WFD device tables */
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_session_info_ie, &pWfdEid->Octet, SUBID_WFD_DEVICE_INFO_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_SESSION_INFO\n", __FUNCTION__));
break;
}
case SUBID_WFD_ALTERNATE_MAC_ADDR:
{
RTMPMoveMemory(&pWfdEntryInfo->wfd_serv_disc_query_info.wfd_alternate_mac_addr_ie, &pWfdEid->Octet, SUBID_WFD_ALTERNATE_MAC_ADDR_LEN);
DBGPRINT(RT_DEBUG_INFO, ("%s::SUBID_WFD_ALTERNATE_MAC_ADDR\n", __FUNCTION__));
break;
}
default:
DBGPRINT(RT_DEBUG_ERROR, (" SUBID_WFD_ unknown Eid = %x \n", pWfdEid->Eid));
hex_dump("WfdParseSubElement::", Msg, MsgLen);
break;
}
// printk("<< Length = %d. AttriLen = %d. AccuWfdIELen = %d.\n", Length, AttriLen, AccuWfdIELen);
Length = Length + 3 + AttriLen; /* Eid[1] + Len[2] + content[Len] */
// printk(">> Length = %d. AttriLen = %d. AccuWfdIELen = %d.\n", Length, AttriLen, AccuWfdIELen);
if (Length >= AccuWfdIELen)
break;
pWfdEid = (PP2PEID_STRUCT)((UCHAR*)pWfdEid + 3 + AttriLen);
AttriLen = pWfdEid->Len[1] + (pWfdEid->Len[0] << 8);
}
}
/* Already reach the final IE and stop finding next Eid. */
if (AccuIeLen >= MsgLen)
break;
/* Forward buffer to next pEid */
if (RTMPEqualMemory(&pEid->Octet[0], WIFIDISPLAY_OUI, 4))
{
pEid = (PEID_STRUCT)((UCHAR*)pEid + pEid->Len + 2);
}
/*
Since we get the next pEid,
Predict the accumulated IeLen after adding the next pEid's length.
The accumulated IeLen is for checking length.
*/
if (RTMPEqualMemory(&pEid->Octet[0], WIFIDISPLAY_OUI, 4))
{
AccuIeLen += (pEid->Len + 2);
}
}
