sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

drivers/usbdev/rindis.c: Change some naming to conform with coding standard. Use DEBUGASSERT vs. assert so that the assertions can be disabled.

Browse Source
This commit is contained in:
Gregory Nutt 2017-09-24 11:18:01 -06:00
parent 67e9e1efb6
commit dbf57fb673
2 changed files with 230 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
drivers/usbdev/rndis.c
View File

@ -157,7 +157,7 @@ struct rndis_dev_s
bool rdreq_submitted; /* Indicates if the read request is submitted */ bool rdreq_submitted; /* Indicates if the read request is submitted */
bool rx_blocked; /* Indicates if we can receive packets on bulk in endpoint */ bool rx_blocked; /* Indicates if we can receive packets on bulk in endpoint */
bool ctrlreq_has_encap_response; /* Indicates if ctrlreq buffer holds a response */ bool ctrlreq_has_encap_response; /* Indicates if ctrlreq buffer holds a response */
bool rndis_connected; /* Connection status indicator */ bool connected; /* Connection status indicator */
uint32_t rndis_packet_filter; /* RNDIS packet filter value */ uint32_t rndis_packet_filter; /* RNDIS packet filter value */
uint32_t rndis_host_tx_count; /* TX packet counter */ uint32_t rndis_host_tx_count; /* TX packet counter */
uint32_t rndis_host_rx_count; /* RX packet counter */ uint32_t rndis_host_rx_count; /* RX packet counter */
@ -197,10 +197,10 @@ struct rndis_cfgdesc_s
struct rndis_oid_value_s struct rndis_oid_value_s
{ {
uint32_t ObjectID; uint32_t objid;
uint32_t Length; uint32_t length;
uint32_t Value; uint32_t value;
FAR const void *Data; /* Data pointer overrides value if non-NULL. */ FAR const void *data; /* Data pointer overrides value if non-NULL. */
}; };
/**************************************************************************** /****************************************************************************
@ -276,8 +276,7 @@ const static struct rndis_cfgdesc_s g_rndis_cfgdesc =
.ninterfaces = 2, .ninterfaces = 2,
.cfgvalue = RNDIS_CONFIGID, .cfgvalue = RNDIS_CONFIGID,
.icfg = 0, .icfg = 0,
.attr = USB_CONFIG_ATTR_ONE | .attr = USB_CONFIG_ATTR_ONE | USB_CONFIG_ATTR_SELFPOWER,
USB_CONFIG_ATTR_SELFPOWER,
.mxpower = 200 / 2 .mxpower = 200 / 2
}, },
{ {
@ -479,6 +478,7 @@ static int rndis_submit_rdreq(FAR struct rndis_dev_s *priv)
* priv: pointer to RNDIS device driver structure * priv: pointer to RNDIS device driver structure
* *
****************************************************************************/ ****************************************************************************/
static void rndis_cancel_rdreq(FAR struct rndis_dev_s *priv) static void rndis_cancel_rdreq(FAR struct rndis_dev_s *priv)
{ {
irqstate_t flags = enter_critical_section(); irqstate_t flags = enter_critical_section();
@ -487,6 +487,7 @@ static void rndis_cancel_rdreq(FAR struct rndis_dev_s *priv)
EP_CANCEL(priv->epbulkout, priv->rdreq); EP_CANCEL(priv->epbulkout, priv->rdreq);
priv->rdreq_submitted = false; priv->rdreq_submitted = false;
} }
leave_critical_section(flags); leave_critical_section(flags);
} }
@ -504,6 +505,7 @@ static void rndis_cancel_rdreq(FAR struct rndis_dev_s *priv)
static void rndis_block_rx(FAR struct rndis_dev_s *priv) static void rndis_block_rx(FAR struct rndis_dev_s *priv)
{ {
irqstate_t flags = enter_critical_section(); irqstate_t flags = enter_critical_section();
priv->rx_blocked = true; priv->rx_blocked = true;
rndis_cancel_rdreq(priv); rndis_cancel_rdreq(priv);
leave_critical_section(flags); leave_critical_section(flags);
@ -591,7 +593,7 @@ static bool rndis_hasfreereqs(FAR struct rndis_dev_s *priv)
static void rndis_freewrreq(FAR struct rndis_dev_s *priv, static void rndis_freewrreq(FAR struct rndis_dev_s *priv,
FAR struct rndis_req_s *req) FAR struct rndis_req_s *req)
{ {
assert(req); DEBUGASSERT(req != NULL);
sq_addlast((FAR sq_entry_t *)req, &priv->reqlist); sq_addlast((FAR sq_entry_t *)req, &priv->reqlist);
rndis_submit_rdreq(priv); rndis_submit_rdreq(priv);
} }
@ -616,7 +618,7 @@ static void rndis_freewrreq(FAR struct rndis_dev_s *priv,
static bool rndis_allocnetreq(FAR struct rndis_dev_s *priv) static bool rndis_allocnetreq(FAR struct rndis_dev_s *priv)
{ {
irqstate_t flags = enter_critical_section(); irqstate_t flags = enter_critical_section();
assert(!priv->net_req); DEBUGASSERT(priv->net_req == NULL);
if (!rndis_hasfreereqs(priv)) if (!rndis_hasfreereqs(priv))
{ {
@ -652,9 +654,12 @@ static bool rndis_allocnetreq(FAR struct rndis_dev_s *priv)
static void rndis_sendnetreq(FAR struct rndis_dev_s *priv) static void rndis_sendnetreq(FAR struct rndis_dev_s *priv)
{ {
irqstate_t flags = enter_critical_section(); irqstate_t flags = enter_critical_section();
assert(priv->net_req);
DEBUGASSERT(priv->net_req != NULL);
priv->net_req->req->priv = priv->net_req; priv->net_req->req->priv = priv->net_req;
EP_SUBMIT(priv->epbulkin, priv->net_req->req); EP_SUBMIT(priv->epbulkin, priv->net_req->req);
priv->net_req = NULL; priv->net_req = NULL;
priv->netdev.d_buf = NULL; priv->netdev.d_buf = NULL;
priv->netdev.d_len = 0; priv->netdev.d_len = 0;
@ -678,6 +683,7 @@ static void rndis_sendnetreq(FAR struct rndis_dev_s *priv)
static void rndis_freenetreq(FAR struct rndis_dev_s *priv) static void rndis_freenetreq(FAR struct rndis_dev_s *priv)
{ {
irqstate_t flags = enter_critical_section(); irqstate_t flags = enter_critical_section();
rndis_freewrreq(priv, priv->net_req); rndis_freewrreq(priv, priv->net_req);
priv->net_req = NULL; priv->net_req = NULL;
priv->netdev.d_buf = NULL; priv->netdev.d_buf = NULL;
@ -729,8 +735,9 @@ static bool rndis_allocrxreq(FAR struct rndis_dev_s *priv)
static void rndis_giverxreq(FAR struct rndis_dev_s *priv) static void rndis_giverxreq(FAR struct rndis_dev_s *priv)
{ {
assert(priv->rx_req); DEBUGASSERT(priv->rx_req != NULL);
assert(!priv->net_req); DEBUGASSERT(priv->net_req == NULL);
priv->net_req = priv->rx_req; priv->net_req = priv->rx_req;
priv->netdev.d_buf = &priv->net_req->req->buf[RNDIS_PACKET_HDR_SIZE]; priv->netdev.d_buf = &priv->net_req->req->buf[RNDIS_PACKET_HDR_SIZE];
priv->netdev.d_len = CONFIG_NET_ETH_MTU; priv->netdev.d_len = CONFIG_NET_ETH_MTU;
@ -758,9 +765,11 @@ static void rndis_giverxreq(FAR struct rndis_dev_s *priv)
static uint16_t rndis_fillrequest(FAR struct rndis_dev_s *priv, static uint16_t rndis_fillrequest(FAR struct rndis_dev_s *priv,
FAR struct usbdev_req_s *req) FAR struct usbdev_req_s *req)
{ {
size_t datalen;
req->len = 0; req->len = 0;
size_t datalen = min(priv->netdev.d_len, datalen = min(priv->netdev.d_len,
CONFIG_RNDIS_BULKIN_REQLEN - RNDIS_PACKET_HDR_SIZE); CONFIG_RNDIS_BULKIN_REQLEN - RNDIS_PACKET_HDR_SIZE);
if (datalen > 0) if (datalen > 0)
{ {
@ -769,10 +778,10 @@ static uint16_t rndis_fillrequest(FAR struct rndis_dev_s *priv,
FAR struct rndis_packet_msg *msg = (FAR struct rndis_packet_msg *)req->buf; FAR struct rndis_packet_msg *msg = (FAR struct rndis_packet_msg *)req->buf;
memset(msg, 0, RNDIS_PACKET_HDR_SIZE); memset(msg, 0, RNDIS_PACKET_HDR_SIZE);
msg->MessageType = RNDIS_PACKET_MSG; msg->msgtype = RNDIS_PACKET_MSG;
msg->MessageLength = RNDIS_PACKET_HDR_SIZE + datalen; msg->msglen = RNDIS_PACKET_HDR_SIZE + datalen;
msg->DataOffset = RNDIS_PACKET_HDR_SIZE - 8; msg->dataoffset = RNDIS_PACKET_HDR_SIZE - 8;
msg->DataLength = datalen; msg->datalen = datalen;
req->flags = USBDEV_REQFLAGS_NULLPKT; req->flags = USBDEV_REQFLAGS_NULLPKT;
req->len = datalen + RNDIS_PACKET_HDR_SIZE; req->len = datalen + RNDIS_PACKET_HDR_SIZE;
@ -795,14 +804,16 @@ static uint16_t rndis_fillrequest(FAR struct rndis_dev_s *priv,
static void rndis_rxdispatch(FAR void *arg) static void rndis_rxdispatch(FAR void *arg)
{ {
FAR struct rndis_dev_s *priv = (FAR struct rndis_dev_s *)arg; FAR struct rndis_dev_s *priv = (FAR struct rndis_dev_s *)arg;
FAR struct eth_hdr_s *hdr;
irqstate_t flags;
net_lock(); net_lock();
irqstate_t flags = enter_critical_section(); flags = enter_critical_section();
rndis_giverxreq(priv); rndis_giverxreq(priv);
priv->netdev.d_len = priv->current_rx_datagram_size; priv->netdev.d_len = priv->current_rx_datagram_size;
leave_critical_section(flags); leave_critical_section(flags);
FAR struct eth_hdr_s *hdr = (FAR struct eth_hdr_s *)priv->netdev.d_buf; hdr = (FAR struct eth_hdr_s *)priv->netdev.d_buf;
/* We only accept IP packets of the configured type and ARP packets */ /* We only accept IP packets of the configured type and ARP packets */
@ -852,7 +863,11 @@ static void rndis_rxdispatch(FAR void *arg)
rndis_txpoll(&priv->netdev); rndis_txpoll(&priv->netdev);
priv->current_rx_datagram_size = 0; priv->current_rx_datagram_size = 0;
rndis_unblock_rx(priv); rndis_unblock_rx(priv);
if (priv->net_req) rndis_freenetreq(priv);
if (priv->net_req != NULL)
{
rndis_freenetreq(priv);
}
net_unlock(); net_unlock();
} }
@ -876,7 +891,10 @@ static int rndis_txpoll(FAR struct net_driver_s *dev)
{ {
FAR struct rndis_dev_s *priv = (FAR struct rndis_dev_s *)dev->d_private; FAR struct rndis_dev_s *priv = (FAR struct rndis_dev_s *)dev->d_private;
if (!priv->rndis_connected) return -EBUSY; if (!priv->connected)
{
return -EBUSY;
}
/* If the polling resulted in data that should be sent out on the network, /* If the polling resulted in data that should be sent out on the network,
* the field d_len is set to a value > 0. * the field d_len is set to a value > 0.
@ -925,7 +943,6 @@ static int rndis_txpoll(FAR struct net_driver_s *dev)
return OK; return OK;
} }
/**************************************************************************** /****************************************************************************
* Name: rndis_pollworker * Name: rndis_pollworker
* *
@ -938,14 +955,18 @@ static void rndis_pollworker(FAR void *arg)
{ {
FAR struct rndis_dev_s *priv = (struct rndis_dev_s *)arg; FAR struct rndis_dev_s *priv = (struct rndis_dev_s *)arg;
DEBUGASSERT(priv); DEBUGASSERT(priv != NULL);
net_lock(); net_lock();
if (rndis_allocnetreq(priv)) if (rndis_allocnetreq(priv))
{ {
devif_timer(&priv->netdev, rndis_txpoll); devif_timer(&priv->netdev, rndis_txpoll);
if (priv->net_req) rndis_freenetreq(priv);
if (priv->net_req != NULL)
{
rndis_freenetreq(priv);
}
} }
net_unlock(); net_unlock();
@ -1028,7 +1049,10 @@ static void rndis_txavail_work(FAR void *arg)
if (rndis_allocnetreq(priv)) if (rndis_allocnetreq(priv))
{ {
devif_poll(&priv->netdev, rndis_txpoll); devif_poll(&priv->netdev, rndis_txpoll);
if (priv->net_req) rndis_freenetreq(priv); if (priv->net_req != NULL)
{
rndis_freenetreq(priv);
}
} }
net_unlock(); net_unlock();
@ -1075,7 +1099,7 @@ static inline int rndis_recvpacket(FAR struct rndis_dev_s *priv,
return -ENOMEM; return -ENOMEM;
} }
if (!priv->rndis_connected) if (!priv->connected)
{ {
return -EBUSY; return -EBUSY;
} }
@ -1091,16 +1115,16 @@ static inline int rndis_recvpacket(FAR struct rndis_dev_s *priv,
/* The packet contains a RNDIS packet message header */ /* The packet contains a RNDIS packet message header */
FAR struct rndis_packet_msg *msg = (FAR struct rndis_packet_msg *)reqbuf; FAR struct rndis_packet_msg *msg = (FAR struct rndis_packet_msg *)reqbuf;
if (msg->MessageType == RNDIS_PACKET_MSG) if (msg->msgtype == RNDIS_PACKET_MSG)
{ {
priv->current_rx_received = reqlen; priv->current_rx_received = reqlen;
priv->current_rx_datagram_size = msg->DataLength; priv->current_rx_datagram_size = msg->datalen;
/* Data offset is defined as an offset from the beginning of the /* Data offset is defined as an offset from the beginning of the
* offset field itself * offset field itself
*/ */
priv->current_rx_datagram_offset = msg->DataOffset + 8; priv->current_rx_datagram_offset = msg->dataoffset + 8;
if (priv->current_rx_datagram_offset < reqlen) if (priv->current_rx_datagram_offset < reqlen)
{ {
memcpy(&priv->rx_req->req->buf[RNDIS_PACKET_HDR_SIZE], memcpy(&priv->rx_req->req->buf[RNDIS_PACKET_HDR_SIZE],
@ -1110,7 +1134,7 @@ static inline int rndis_recvpacket(FAR struct rndis_dev_s *priv,
} }
else else
{ {
uerr("Unknown RNDIS message type %u\n", msg->MessageType); uerr("Unknown RNDIS message type %u\n", msg->msgtype);
} }
} }
} }
@ -1142,10 +1166,11 @@ static inline int rndis_recvpacket(FAR struct rndis_dev_s *priv,
{ {
int ret; int ret;
assert(work_available(&priv->rxwork)); DEBUGASSERT(work_available(&priv->rxwork));
ret = work_queue(HPWORK, &priv->rxwork, rndis_rxdispatch, ret = work_queue(HPWORK, &priv->rxwork, rndis_rxdispatch,
priv, 0); priv, 0);
assert(ret == 0); DEBUGASSERT(ret == 0);
rndis_block_rx(priv); rndis_block_rx(priv);
priv->rndis_host_tx_count++; priv->rndis_host_tx_count++;
return -EBUSY; return -EBUSY;
@ -1182,10 +1207,10 @@ static bool rndis_prepare_response(FAR struct rndis_dev_s *priv, size_t size,
FAR struct rndis_response_header *hdr = FAR struct rndis_response_header *hdr =
(FAR struct rndis_response_header *)priv->ctrlreq->buf; (FAR struct rndis_response_header *)priv->ctrlreq->buf;
hdr->MessageType = request_hdr->MessageType | RNDIS_MSG_COMPLETE; hdr->msgtype = request_hdr->msgtype | RNDIS_MSG_COMPLETE;
hdr->MessageLength = size; hdr->msglen = size;
hdr->RequestID = request_hdr->RequestID; hdr->reqid = request_hdr->reqid;
hdr->Status = RNDIS_STATUS_SUCCESS; hdr->status = RNDIS_STATUS_SUCCESS;
priv->ctrlreq_has_encap_response = true; priv->ctrlreq_has_encap_response = true;
@ -1212,8 +1237,8 @@ static int rndis_send_encapsulated_response(FAR struct rndis_dev_s *priv)
FAR struct rndis_notification *notif = FAR struct rndis_notification *notif =
(FAR struct rndis_notification *)priv->epintin_req->buf; (FAR struct rndis_notification *)priv->epintin_req->buf;
notif->Notification = RNDIS_NOTIFICATION_RESPONSE_AVAILABLE; notif->notification = RNDIS_NOTIFICATION_RESPONSE_AVAILABLE;
notif->Reserved = 0; notif->reserved = 0;
priv->epintin_req->len = sizeof(struct rndis_notification); priv->epintin_req->len = sizeof(struct rndis_notification);
EP_CANCEL(priv->epintin, priv->epintin_req); EP_CANCEL(priv->epintin, priv->epintin_req);
@ -1242,7 +1267,7 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
FAR struct rndis_command_header *cmd_hdr = FAR struct rndis_command_header *cmd_hdr =
(FAR struct rndis_command_header *)dataout; (FAR struct rndis_command_header *)dataout;
switch (cmd_hdr->MessageType) switch (cmd_hdr->msgtype)
{ {
case RNDIS_INITIALIZE_MSG: case RNDIS_INITIALIZE_MSG:
{ {
@ -1251,13 +1276,13 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
rndis_prepare_response(priv, sizeof(struct rndis_initialize_cmplt), cmd_hdr); rndis_prepare_response(priv, sizeof(struct rndis_initialize_cmplt), cmd_hdr);
resp = (FAR struct rndis_initialize_cmplt *)priv->ctrlreq->buf; resp = (FAR struct rndis_initialize_cmplt *)priv->ctrlreq->buf;
resp->MajorVersion = RNDIS_MAJOR_VERSION; resp->major = RNDIS_MAJOR_VERSION;
resp->MinorVersion = RNDIS_MINOR_VERSION; resp->minor = RNDIS_MINOR_VERSION;
resp->DeviceFlags = RNDIS_DEVICEFLAGS; resp->devflags = RNDIS_DEVICEFLAGS;
resp->Medium = RNDIS_MEDIUM_802_3; resp->medium = RNDIS_MEDIUM_802_3;
resp->MaxPacketsPerTransfer = 1; resp->pktperxfer = 1;
resp->MaxTransferSize = 36 + RNDIS_BUFFER_SIZE; resp->xfrsize = 36 + RNDIS_BUFFER_SIZE;
resp->PacketAlignmentFactor = 2; resp->pktalign = 2;
rndis_send_encapsulated_response(priv); rndis_send_encapsulated_response(priv);
} }
@ -1265,7 +1290,7 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
case RNDIS_HALT_MSG: case RNDIS_HALT_MSG:
{ {
priv->rndis_connected = false; priv->connected = false;
} }
break; break;
@ -1280,18 +1305,18 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
FAR struct rndis_query_cmplt *resp = FAR struct rndis_query_cmplt *resp =
(FAR struct rndis_query_cmplt *)priv->ctrlreq->buf; (FAR struct rndis_query_cmplt *)priv->ctrlreq->buf;
resp->hdr.MessageLength = sizeof(struct rndis_query_cmplt); resp->hdr.msglen = sizeof(struct rndis_query_cmplt);
resp->InformationBufferOffset = 0; resp->bufoffset = 0;
resp->InformationBufferLength = 0; resp->buflen = 0;
resp->hdr.Status = RNDIS_STATUS_NOT_SUPPORTED; resp->hdr.status = RNDIS_STATUS_NOT_SUPPORTED;
for (i = 0; for (i = 0;
i < sizeof(g_rndis_oid_values)/sizeof(g_rndis_oid_values[0]); i < sizeof(g_rndis_oid_values)/sizeof(g_rndis_oid_values[0]);
i++) i++)
{ {
bool match = (g_rndis_oid_values[i].ObjectID == req->ObjectID); bool match = (g_rndis_oid_values[i].objid == req->objid);
if (!match && g_rndis_oid_values[i].ObjectID == 0) if (!match && g_rndis_oid_values[i].objid == 0)
{ {
int j; int j;
@ -1299,7 +1324,7 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
for (j = 0; j < sizeof(g_rndis_supported_oids)/sizeof(uint32_t); j++) for (j = 0; j < sizeof(g_rndis_supported_oids)/sizeof(uint32_t); j++)
{ {
if (g_rndis_supported_oids[j] == req->ObjectID) if (g_rndis_supported_oids[j] == req->objid)
{ {
match = true; match = true;
break; break;
@ -1309,46 +1334,46 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
if (match) if (match)
{ {
resp->hdr.Status = RNDIS_STATUS_SUCCESS; resp->hdr.status = RNDIS_STATUS_SUCCESS;
resp->InformationBufferOffset = 16; resp->bufoffset = 16;
resp->InformationBufferLength = g_rndis_oid_values[i].Length; resp->buflen = g_rndis_oid_values[i].length;
if (req->ObjectID == RNDIS_OID_GEN_CURRENT_PACKET_FILTER) if (req->objid == RNDIS_OID_GEN_CURRENT_PACKET_FILTER)
{ {
resp->Buffer[0] = priv->rndis_packet_filter; resp->buffer[0] = priv->rndis_packet_filter;
} }
else if (req->ObjectID == RNDIS_OID_GEN_XMIT_OK) else if (req->objid == RNDIS_OID_GEN_XMIT_OK)
{ {
resp->Buffer[0] = priv->rndis_host_tx_count; resp->buffer[0] = priv->rndis_host_tx_count;
} }
else if (req->ObjectID == RNDIS_OID_GEN_RCV_OK) else if (req->objid == RNDIS_OID_GEN_RCV_OK)
{ {
resp->Buffer[0] = priv->rndis_host_rx_count; resp->buffer[0] = priv->rndis_host_rx_count;
} }
else if (req->ObjectID == RNDIS_OID_802_3_CURRENT_ADDRESS || else if (req->objid == RNDIS_OID_802_3_CURRENT_ADDRESS ||
req->ObjectID == RNDIS_OID_802_3_PERMANENT_ADDRESS) req->objid == RNDIS_OID_802_3_PERMANENT_ADDRESS)
{ {
memcpy(resp->Buffer, priv->host_mac_address, 6); memcpy(resp->buffer, priv->host_mac_address, 6);
} }
else if (g_rndis_oid_values[i].Data) else if (g_rndis_oid_values[i].data)
{ {
memcpy(resp->Buffer, g_rndis_oid_values[i].Data, memcpy(resp->buffer, g_rndis_oid_values[i].data,
resp->InformationBufferLength); resp->buflen);
} }
else else
{ {
memcpy(resp->Buffer, &g_rndis_oid_values[i].Value, memcpy(resp->buffer, &g_rndis_oid_values[i].value,
resp->InformationBufferLength); resp->buflen);
} }
break; break;
} }
} }
uinfo("RNDIS Query RID=%08x OID=%08x LEN=%d DAT=%08x", uinfo("RNDIS Query RID=%08x OID=%08x LEN=%d DAT=%08x",
(unsigned)req->hdr.RequestID, (unsigned)req->ObjectID, (unsigned)req->hdr.reqid, (unsigned)req->objid,
(int)resp->InformationBufferLength, (unsigned)resp->Buffer[0]); (int)resp->buflen, (unsigned)resp->buffer[0]);
resp->hdr.MessageLength += resp->InformationBufferLength; resp->hdr.msglen += resp->buflen;
rndis_send_encapsulated_response(priv); rndis_send_encapsulated_response(priv);
} }
@ -1365,31 +1390,31 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
resp = (FAR struct rndis_response_header *)priv->ctrlreq->buf; resp = (FAR struct rndis_response_header *)priv->ctrlreq->buf;
uinfo("RNDIS SET RID=%08x OID=%08x LEN=%d DAT=%08x", uinfo("RNDIS SET RID=%08x OID=%08x LEN=%d DAT=%08x",
(unsigned)req->hdr.RequestID, (unsigned)req->ObjectID, (unsigned)req->hdr.reqid, (unsigned)req->objid,
(int)req->InformationBufferLength, (unsigned)req->Buffer[0]); (int)req->buflen, (unsigned)req->buffer[0]);
if (req->ObjectID == RNDIS_OID_GEN_CURRENT_PACKET_FILTER) if (req->objid == RNDIS_OID_GEN_CURRENT_PACKET_FILTER)
{ {
priv->rndis_packet_filter = req->Buffer[0]; priv->rndis_packet_filter = req->buffer[0];
if (req->Buffer[0] == 0) if (req->buffer[0] == 0)
{ {
priv->rndis_connected = false; priv->connected = false;
} }
else else
{ {
uinfo("RNDIS is now connected"); uinfo("RNDIS is now connected");
priv->rndis_connected = true; priv->connected = true;
} }
} }
else if (req->ObjectID == RNDIS_OID_802_3_MULTICAST_LIST) else if (req->objid == RNDIS_OID_802_3_MULTICAST_LIST)
{ {
uinfo("RNDIS multicast list ignored"); uinfo("RNDIS multicast list ignored");
} }
else else
{ {
uinfo("RNDIS unsupported set %08x", (unsigned)req->ObjectID); uinfo("RNDIS unsupported set %08x", (unsigned)req->objid);
resp->Status = RNDIS_STATUS_NOT_SUPPORTED; resp->status = RNDIS_STATUS_NOT_SUPPORTED;
} }
rndis_send_encapsulated_response(priv); rndis_send_encapsulated_response(priv);
@ -1403,8 +1428,8 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
rndis_prepare_response(priv, sizeof(struct rndis_reset_cmplt), rndis_prepare_response(priv, sizeof(struct rndis_reset_cmplt),
cmd_hdr); cmd_hdr);
resp = (FAR struct rndis_reset_cmplt *)priv->ctrlreq->buf; resp = (FAR struct rndis_reset_cmplt *)priv->ctrlreq->buf;
resp->AddressingReset = 0; resp->addreset = 0;
priv->rndis_connected = false; priv->connected = false;
rndis_send_encapsulated_response(priv); rndis_send_encapsulated_response(priv);
} }
break; break;
@ -1418,7 +1443,7 @@ static int rndis_handle_control_message(FAR struct rndis_dev_s *priv,
break; break;
default: default:
uwarn("Unsupported RNDIS control message: %u\n", cmd_hdr->MessageType); uwarn("Unsupported RNDIS control message: %u\n", cmd_hdr->msgtype);
} }
return OK; return OK;
@ -1464,7 +1489,7 @@ static void rndis_rdcomplete(FAR struct usbdev_ep_s *ep,
{ {
case 0: /* Normal completion */ case 0: /* Normal completion */
ret = rndis_recvpacket(priv, req->buf, req->xfrd); ret = rndis_recvpacket(priv, req->buf, req->xfrd);
assert(ret != -ENOMEM); DEBUGASSERT(ret != -ENOMEM);
break; break;
case -ESHUTDOWN: /* Disconnection */ case -ESHUTDOWN: /* Disconnection */
@ -2155,8 +2180,11 @@ static int usbclass_setup(FAR struct usbdevclass_driver_s *driver,
/* There is data prepared in the ctrlreq buffer. /* There is data prepared in the ctrlreq buffer.
* Just assign the length. * Just assign the length.
*/ */
struct rndis_response_header *hdr = (struct rndis_response_header *)ctrlreq->buf;
ret = hdr->MessageLength; FAR struct rndis_response_header *hdr =
(struct rndis_response_header *)ctrlreq->buf;
ret = hdr->msglen;
} }
} }
} }
@ -2334,6 +2362,7 @@ static int usbclass_setconfig(FAR struct rndis_dev_s *priv, uint8_t config)
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPINTINCONFIGFAIL), 0); usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPINTINCONFIGFAIL), 0);
goto errout; goto errout;
} }
priv->epintin->priv = priv; priv->epintin->priv = priv;
/* Configure the IN bulk endpoint */ /* Configure the IN bulk endpoint */
@ -2373,7 +2402,10 @@ static int usbclass_setconfig(FAR struct rndis_dev_s *priv, uint8_t config)
/* We are successfully configured */ /* We are successfully configured */
priv->config = config; priv->config = config;
if (priv->netdev.d_ifup(&priv->netdev) == OK) priv->netdev.d_flags |= IFF_UP; if (priv->netdev.d_ifup(&priv->netdev) == OK)
{
priv->netdev.d_flags |= IFF_UP;
}
return OK; return OK;

100
drivers/usbdev/rndis_std.h
View File

@ -114,102 +114,102 @@
struct rndis_notification struct rndis_notification
{ {
uint32_t Notification; uint32_t notification; /* Notification */
uint32_t Reserved; uint32_t reserved; /* Reserved */
}; };
struct rndis_command_header struct rndis_command_header
{ {
uint32_t MessageType; uint32_t msgtype; /* MessageType */
uint32_t MessageLength; uint32_t msglen; /* MessageLength */
uint32_t RequestID; uint32_t reqid; /* RequestID */
}; };
struct rndis_response_header struct rndis_response_header
{ {
uint32_t MessageType; uint32_t msgtype; /* MessageType */
uint32_t MessageLength; uint32_t msglen; /* MessageLength */
uint32_t RequestID; uint32_t reqid; /* RequestID */
uint32_t Status; uint32_t status; /* Status */
}; };
struct rndis_initialize_msg struct rndis_initialize_msg
{ {
struct rndis_command_header hdr; struct rndis_command_header hdr;
uint32_t MajorVersion; uint32_t major; /* MajorVersion */
uint32_t MinorVersion; uint32_t minor; /* MinorVersion */
uint32_t MaxTransferSize; uint32_t xfrsize; /* MaxTransferSize */
}; };
struct rndis_initialize_cmplt struct rndis_initialize_cmplt
{ {
struct rndis_response_header hdr; struct rndis_response_header hdr;
uint32_t MajorVersion; uint32_t major; /* MajorVersion */
uint32_t MinorVersion; uint32_t minor; /* MinorVersion */
uint32_t DeviceFlags; uint32_t devflags; /* DeviceFlags */
uint32_t Medium; uint32_t medium; /* Medium */
uint32_t MaxPacketsPerTransfer; uint32_t pktperxfer; /* MaxPacketsPerTransfer */
uint32_t MaxTransferSize; uint32_t xfrsize; /* MaxTransferSize */
uint32_t PacketAlignmentFactor; uint32_t pktalign; /* PacketAlignmentFactor */
uint32_t Reserved1; uint32_t reserved1; /* Reserved1 */
uint32_t Reserved2; uint32_t reserved2; /* Reserved2 */
}; };
struct rndis_query_msg struct rndis_query_msg
{ {
struct rndis_command_header hdr; struct rndis_command_header hdr;
uint32_t ObjectID; uint32_t objid; /* ObjectID */
uint32_t InformationBufferLength; uint32_t buflen; /* InformationBufferLength */
uint32_t InformationBufferOffset; uint32_t bufoffset; /* InformationBufferOffset */
uint32_t Reserved; uint32_t reserved; /* Reserved */
uint32_t Buffer[]; uint32_t buffer[]; /* Buffer */
}; };
struct rndis_query_cmplt struct rndis_query_cmplt
{ {
struct rndis_response_header hdr; struct rndis_response_header hdr;
uint32_t InformationBufferLength; uint32_t buflen; /* InformationBufferLength */
uint32_t InformationBufferOffset; uint32_t bufoffset; /* InformationBufferOffset */
uint32_t Buffer[]; uint32_t buffer[]; /* Buffer */
}; };
struct rndis_set_msg struct rndis_set_msg
{ {
struct rndis_command_header hdr; struct rndis_command_header hdr;
uint32_t ObjectID; uint32_t objid; /* ObjectID */
uint32_t InformationBufferLength; uint32_t buflen; /* InformationBufferLength */
uint32_t InformationBufferOffset; uint32_t bufoffset; /* InformationBufferOffset */
uint32_t Reserved; uint32_t reserved; /* Reserved */
uint32_t Buffer[]; uint32_t buffer[]; /* Buffer */
}; };
struct rndis_reset_cmplt struct rndis_reset_cmplt
{ {
struct rndis_response_header hdr; struct rndis_response_header hdr;
uint32_t AddressingReset; uint32_t addreset; /* AddressingReset */
}; };
struct rndis_indicate_msg struct rndis_indicate_msg
{ {
uint32_t MessageType; uint32_t msgtype; /* MessageType */
uint32_t MessageLength; uint32_t msglen; /* MessageLength */
uint32_t Status; uint32_t status; /* Status */
uint32_t StatusBufferLength; uint32_t buflen; /* StatusBufferLength */
uint32_t StatusBufferOffset; uint32_t bufoffset; /* StatusBufferOffset */
uint32_t Buffer[]; uint32_t buffer[]; /* Buffer */
}; };
struct rndis_packet_msg struct rndis_packet_msg
{ {
uint32_t MessageType; uint32_t msgtype; /* MessageType */
uint32_t MessageLength; uint32_t msglen; /* MessageLength */
uint32_t DataOffset; uint32_t dataoffset; /* DataOffset */
uint32_t DataLength; uint32_t datalen; /* DataLength */
uint32_t OutOfBandDataOffset; uint32_t ooboffset; /* OutOfBandDataOffset */
uint32_t OutOfBandDataLength; uint32_t ooblen; /* OutOfBandDataLength */
uint32_t NumOutOfBandDataElements; uint32_t noobelem; /* NumOutOfBandDataElements */
uint32_t PerPacketInfoOffset; uint32_t infooffset; /* PerPacketInfoOffset */
uint32_t PerPacketInfoLength; uint32_t infolen; /* PerPacketInfoLength */
}; };
#endif #endif