#include "app_config.h" #include "usb_host.h" #include "usbnet.h" #include "cdc_defs.h" #include "device_drive.h" #include "host/usb_ctrl_transfer.h" #if TCFG_HOST_WIRELESS_ENABLE #define LOG_TAG_CONST USB #define LOG_TAG "[net]" #define LOG_ERROR_ENABLE #define LOG_DEBUG_ENABLE #define LOG_INFO_ENABLE /* #define LOG_DUMP_ENABLE */ #define LOG_CLI_ENABLE #include "debug.h" #define EL3RST (40) /* Level 3 reset */ #define ETH_ALEN (6) /* #define ETIMEDOUT (238) [> Connection timed out <] */ static USBNET_RX_COMPLETE_CB usbnet_rx_complete_cb = NULL; static void keepalive_period_task(void *priv); static void (*usbnet_at_port_rx_handler)(u8 *buf, u32 len) = NULL; static int set_power(struct usb_host_device *host_dev, u32 value) { return DEV_ERR_NONE; } static int get_power(struct usb_host_device *host_dev, u32 value) { return DEV_ERR_NONE; } static struct wireless_device_t wireless_dev[USB_MAX_HW_NUM]; static const struct interface_ctrl wireless_ctrl = { .interface_class = USB_CLASS_WIRELESS_CONTROLLER, .set_power = set_power, .get_power = get_power, .ioctl = NULL, }; static const struct interface_ctrl at_port_ctrl = { .interface_class = USB_CLASS_VENDOR_SPEC, .set_power = set_power, .get_power = get_power, .ioctl = NULL, }; static const struct usb_interface_info wireless_inf[USB_MAX_HW_NUM] = { { .ctrl = (struct interface_ctrl *) &wireless_ctrl, .dev.wireless = &wireless_dev[0], }, #if USB_MAX_HW_NUM > 1 { .ctrl = (struct interface_ctrl *) &wireless_ctrl, .dev.wireless = &wireless_dev[1], } #endif }; static const struct usb_interface_info at_port_inf[USB_MAX_HW_NUM] = { { .ctrl = (struct interface_ctrl *) &at_port_ctrl, .dev.wireless = &wireless_dev[0], }, #if USB_MAX_HW_NUM > 1 { .ctrl = (struct interface_ctrl *) &at_port_ctrl, .dev.wireless = &wireless_dev[1], } #endif }; void __attribute__((weak)) copy_usbnet_mac_addr(u8 *mac) { } void usb_net_stop_process(usb_dev usb_id) { if (wireless_dev[usb_id].epin_buf) { usb_h_free_ep_buffer(usb_id, wireless_dev[usb_id].epin_buf); wireless_dev[usb_id].epin_buf = NULL; } if (wireless_dev[usb_id].epout_buf) { usb_h_free_ep_buffer(usb_id, wireless_dev[usb_id].epout_buf); wireless_dev[usb_id].epout_buf = NULL; } if (wireless_dev[usb_id].inbuf) { free(wireless_dev[usb_id].inbuf); wireless_dev[usb_id].inbuf = NULL; } } void usb_net_at_port_stop_process(usb_dev usb_id) { if (wireless_dev[usb_id].epin_buf_at) { usb_h_free_ep_buffer(usb_id, wireless_dev[usb_id].epin_buf_at); wireless_dev[usb_id].epin_buf_at = NULL; } if (wireless_dev[usb_id].epout_buf_at) { usb_h_free_ep_buffer(usb_id, wireless_dev[usb_id].epout_buf_at); wireless_dev[usb_id].epout_buf_at = NULL; } } int is_wireless_rndis(struct usb_interface_descriptor *desc) { return (desc->bInterfaceClass == USB_CLASS_WIRELESS_CONTROLLER && desc->bInterfaceSubClass == 1 && desc->bInterfaceProtocol == 3); } int usbnet_host_bulk_only_send(usb_dev usb_id, u8 *buf, u32 len) { return usb_h_bulk_write(usb_id, wireless_dev[usb_id].host_epout, wireless_dev[usb_id].txmaxp, wireless_dev[usb_id].epout, buf, len); } int usbnet_host_at_data_send(usb_dev usb_id, u8 *buf, u32 len) { return usb_h_bulk_write(usb_id, wireless_dev[usb_id].host_epout_at, wireless_dev[usb_id].txmaxp_at, wireless_dev[usb_id].epout_at, buf, len); } void usbnet_set_rx_complete_cb(USBNET_RX_COMPLETE_CB cb) { usbnet_rx_complete_cb = cb; } int usbnet_get_rxmaxp(usb_dev usb_id) { return wireless_dev[usb_id].rxmaxp; } void usbnet_host_bulk_only_receive_int(usb_dev usb_id) { if (wireless_dev[usb_id].inbuf) { //触发传输由上层决定，否则buffer会有改写的风险 usb_h_ep_read_async(usb_id, wireless_dev[usb_id].host_epin, wireless_dev[usb_id].epin, NULL, 0, USB_ENDPOINT_XFER_BULK, 1); } } static void usbnet_rx_isr(struct usb_host_device *host_dev, u32 ep) { int rx_len = 0; usb_dev usb_id = host_device2id(host_dev); u32 target_ep = wireless_dev[usb_id].epin; if (!wireless_dev[usb_id].inbuf) { return; } rx_len = usb_h_ep_read_async(usb_id, ep, target_ep, wireless_dev[usb_id].inbuf, wireless_dev[usb_id].rxmaxp, USB_ENDPOINT_XFER_BULK, 0); if (rx_len > 0 && usbnet_rx_complete_cb) { usbnet_rx_complete_cb(usb_id, wireless_dev[usb_id].inbuf, rx_len); } if (rx_len == 0 || !usbnet_rx_complete_cb) { usb_h_ep_read_async(usb_id, ep, target_ep, NULL, 0, USB_ENDPOINT_XFER_BULK, 1); } } void usbnet_at_port_rx_handler_register(void (*func)(u8 *buf, u32 len)) { usbnet_at_port_rx_handler = func; } static void usbnet_at_port_rx_isr(struct usb_host_device *host_dev, u32 ep) { int rx_len = 0; usb_dev usb_id = host_device2id(host_dev); u32 target_ep = wireless_dev[usb_id].epin_at; u8 usb_recv_buf[64]; u8 usb_recv_len = sizeof(usb_recv_buf); /* printf("usb%d lte rx hep %d %d tep %d \n", usb_id, ep, wireless_dev.host_epin_at, target_ep); */ rx_len = usb_h_ep_read_async(usb_id, ep, target_ep, usb_recv_buf, usb_recv_len, USB_ENDPOINT_XFER_BULK, 0); if (rx_len > 0) { if (usbnet_at_port_rx_handler) { usbnet_at_port_rx_handler(usb_recv_buf, rx_len); } } usb_h_ep_read_async(usb_id, ep, target_ep, NULL, 0, USB_ENDPOINT_XFER_BULK, 1); } s32 usbnet_at_port_parser(struct usb_host_device *host_dev, u8 interface_num, const u8 *pBuf) { s32 len = 0; u8 rx_interval = 0; const usb_dev usb_id = host_device2id(host_dev); struct usb_endpoint_descriptor *end_desc = NULL; struct usb_interface_descriptor *interface = NULL; host_dev->interface_info[interface_num] = &at_port_inf[usb_id]; u32 cur_len; u32 cur_type; u32 cur_subtype; u8 is_next_interface = 0; u8 stage = 0; const u8 cs_interface_1[] = {0x05, 0x24, 0x00, 0x10, 0x01}; const u8 cs_interface_2[] = {0x05, 0x24, 0x01, 0x00, 0x00}; const u8 cs_interface_3[] = {0x04, 0x24, 0x02, 0x02}; const u8 cs_interface_4[] = {0x05, 0x24, 0x06, 0x00, 0x00}; while (1) { cur_len = pBuf[len + 0]; cur_type = pBuf[len + 1]; cur_subtype = pBuf[len + 2]; /* printf("cur_len = %x, cur_type = %x, cur_subtype = %x", cur_len, cur_type, cur_subtype); */ if (cur_type == USB_DT_INTERFACE_ASSOCIATION) { if (is_next_interface) { break; } /* put_buf(pBuf + len, cur_len); */ } else if (cur_type == USB_DT_INTERFACE) { interface = (struct usb_interface_descriptor *)(pBuf + len); if (interface->bLength != USB_DT_INTERFACE_SIZE) { break; } if (is_next_interface) { break; } is_next_interface = 1; /* put_buf(pBuf + len, cur_len); */ } else if (cur_type == USB_DT_CS_INTERFACE) { /* put_buf(pBuf + len, cur_len); */ switch (stage) { case 0: if (!memcmp(pBuf + len, cs_interface_1, sizeof(cs_interface_1))) { stage = 1; } else { stage = 0; } break; case 1: if (!memcmp(pBuf + len, cs_interface_2, sizeof(cs_interface_2))) { stage = 2; } else { stage = 0; } break; case 2: if (!memcmp(pBuf + len, cs_interface_3, sizeof(cs_interface_3))) { stage = 3; } else { stage = 0; } break; case 3: if (!memcmp(pBuf + len, cs_interface_4, sizeof(cs_interface_4))) { stage = 4; } else { stage = 0; } break; } } else if (cur_type == USB_DT_ENDPOINT) { /* put_buf(pBuf + len, cur_len); */ end_desc = (struct usb_endpoint_descriptor *)(pBuf + len); if (stage != 4) { //过滤符合AT COM的CS INTERFACE goto __parser_next; } if ((end_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) { if (end_desc->bEndpointAddress & USB_DIR_IN) { if (end_desc->bEndpointAddress != 0x84 && \ end_desc->bEndpointAddress != 0x86) { //4G模块有好几个接形式一样的interface-endpoint接口，固定取AT COM端点 goto __parser_next; } wireless_dev[usb_id].host_epin_at = usb_get_ep_num(usb_id, USB_DIR_IN, USB_ENDPOINT_XFER_BULK); wireless_dev[usb_id].epin_at = end_desc->bEndpointAddress & 0x0f; wireless_dev[usb_id].rxmaxp_at = end_desc->wMaxPacketSize; rx_interval = end_desc->bInterval; log_info("AT IN : id = %d, host_epin_at = %d, epin_at = %d, rxmaxp_at = %d", usb_id, wireless_dev[usb_id].host_epin_at, wireless_dev[usb_id].epin_at, wireless_dev[usb_id].rxmaxp_at); if (usb_id == 0) { wireless_dev[usb_id].rxmaxp_at = 64; } #if HUSB_MODE && (FUSB_MODE == 0) if (wireless_dev[usb_id].rxmaxp_at > 512) { wireless_dev[usb_id].rxmaxp_at = 512; } #endif usb_h_set_ep_isr(host_dev, wireless_dev[usb_id].host_epin_at | USB_DIR_IN, usbnet_at_port_rx_isr, host_dev); if (!wireless_dev[usb_id].epin_buf_at) { wireless_dev[usb_id].epin_buf_at = usb_h_alloc_ep_buffer(usb_id, wireless_dev[usb_id].host_epin_at | USB_DIR_IN, wireless_dev[usb_id].rxmaxp_at * 2); } usb_write_rxfuncaddr(usb_id, wireless_dev[usb_id].host_epin_at, host_dev->private_data.devnum); usb_h_ep_config(usb_id, wireless_dev[usb_id].host_epin_at | USB_DIR_IN, USB_ENDPOINT_XFER_BULK, 1, rx_interval, wireless_dev[usb_id].epin_buf_at, wireless_dev[usb_id].rxmaxp_at); usb_h_ep_read_async(usb_id, wireless_dev[usb_id].host_epin_at, wireless_dev[usb_id].epin_at, NULL, 0, USB_ENDPOINT_XFER_BULK, 1); } else { if (end_desc->bEndpointAddress != 0x03 && \ end_desc->bEndpointAddress != 0x0F) { //4G模块有好几个接形式一样的interface-endpoint接口，固定取AT COM端点 goto __parser_next; } wireless_dev[usb_id].host_epout_at = usb_get_ep_num(usb_id, USB_DIR_OUT, USB_ENDPOINT_XFER_BULK); wireless_dev[usb_id].epout_at = end_desc->bEndpointAddress & 0x0f; wireless_dev[usb_id].txmaxp_at = end_desc->wMaxPacketSize; log_info("AT OUT : id = %d, host_epout_at = %d, epout_at = %d, txmaxp_at = %d", usb_id, wireless_dev[usb_id].host_epout_at, wireless_dev[usb_id].epout_at, wireless_dev[usb_id].txmaxp_at); if (usb_id == 0) { wireless_dev[usb_id].txmaxp_at = 64; } #if HUSB_MODE && (FUSB_MODE == 0) if (wireless_dev[usb_id].txmaxp_at > 512) { wireless_dev[usb_id].txmaxp_at = 512; } #endif if (!wireless_dev[usb_id].epout_buf_at) { wireless_dev[usb_id].epout_buf_at = usb_h_alloc_ep_buffer(usb_id, wireless_dev[usb_id].host_epout_at | USB_DIR_OUT, wireless_dev[usb_id].txmaxp_at); } usb_write_txfuncaddr(usb_id, wireless_dev[usb_id].host_epout_at, host_dev->private_data.devnum); usb_h_ep_config(usb_id, wireless_dev[usb_id].host_epout_at | USB_DIR_OUT, USB_ENDPOINT_XFER_BULK, 0, 0, wireless_dev[usb_id].epout_buf_at, wireless_dev[usb_id].txmaxp_at); } } } else if (cur_type == USB_DT_CS_ENDPOINT) { /* put_buf(pBuf + len, cur_len); */ } else { break; } __parser_next: len += cur_len; } return len; } s32 usbnet_generic_cdc_parser(struct usb_host_device *host_dev, u8 interface_num, const u8 *pBuf) { int len = 0; u8 loop = 1; u8 rx_interval = 0; const usb_dev usb_id = host_device2id(host_dev); host_dev->interface_info[interface_num] = &wireless_inf[usb_id]; struct usb_interface_descriptor *interface = (struct usb_interface_descriptor *)pBuf; wireless_inf[usb_id].dev.wireless->parent = host_dev; struct usb_endpoint_descriptor *end_desc = NULL; const u8 *buf = pBuf; if (interface->bInterfaceClass == USB_CLASS_CDC_DATA) { log_info("usb_cdc_parser"); len += sizeof(struct usb_interface_descriptor); goto __set_config; } len += sizeof(struct usb_interface_descriptor); buf += sizeof(struct usb_interface_descriptor); while (loop) { if (buf[1] != USB_DT_CS_INTERFACE) { if (buf[1] == USB_DT_INTERFACE_ASSOCIATION) { //下一个设备 loop = 0; break; } goto next_desc; } /* use bDescriptorSubType to identify the CDC descriptors. * We expect devices with CDC header and union descriptors. * For CDC Ethernet we need the ethernet descriptor. * For RNDIS, ignore two (pointless) CDC modem descriptors * in favor of a complicated OID-based RPC scheme doing what * CDC Ethernet achieves with a simple descriptor. */ switch (buf[2]) { case USB_CDC_HEADER_TYPE: break; case USB_CDC_ACM_TYPE: /* paranoia: disambiguate a "real" vendor-specific * modem interface from an RNDIS non-modem. */ break; case USB_CDC_UNION_TYPE: len += buf [0]; /* bLength */ buf += buf [0]; if (buf[1] == USB_DT_ENDPOINT) { len += USB_DT_ENDPOINT_SIZE; len += USB_DT_INTERFACE_SIZE; __set_config: for (int endnum = 0; endnum < 2; endnum++) { end_desc = (struct usb_endpoint_descriptor *)(pBuf + len); if (end_desc->bDescriptorType != USB_DT_ENDPOINT || end_desc->bLength < USB_DT_ENDPOINT_SIZE) { return -USB_DT_ENDPOINT; } len += USB_DT_ENDPOINT_SIZE; if ((end_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) { if (end_desc->bEndpointAddress & USB_DIR_IN) { wireless_dev[usb_id].host_epin = usb_get_ep_num(usb_id, USB_DIR_IN, USB_ENDPOINT_XFER_BULK); wireless_dev[usb_id].epin = end_desc->bEndpointAddress & 0x0f; wireless_dev[usb_id].rxmaxp = end_desc->wMaxPacketSize; if (usb_id == 0) { wireless_dev[usb_id].rxmaxp = 64; } #if HUSB_MODE && (FUSB_MODE == 0) if (wireless_dev[usb_id].rxmaxp > 512) { wireless_dev[usb_id].rxmaxp = 512; } #endif rx_interval = end_desc->bInterval; log_info("CDC IN : id = %d, host_epin = %d, epin = %d, rxmaxp = %d", usb_id, wireless_dev[usb_id].host_epin, wireless_dev[usb_id].epin, wireless_dev[usb_id].rxmaxp); } else { wireless_dev[usb_id].host_epout = usb_get_ep_num(usb_id, USB_DIR_OUT, USB_ENDPOINT_XFER_BULK); wireless_dev[usb_id].epout = end_desc->bEndpointAddress & 0x0f; wireless_dev[usb_id].txmaxp = end_desc->wMaxPacketSize; if (usb_id == 0) { wireless_dev[usb_id].txmaxp = 64; } #if HUSB_MODE && (FUSB_MODE == 0) if (wireless_dev[usb_id].txmaxp > 512) { wireless_dev[usb_id].txmaxp = 512; } #endif log_info("CDC OUT2 : id = %d, host_epout = %d, epout = %d, txmaxp = %d", usb_id, wireless_dev[usb_id].host_epout, wireless_dev[usb_id].epout, wireless_dev[usb_id].txmaxp); } } } usb_h_set_ep_isr(host_dev, wireless_dev[usb_id].host_epin | USB_DIR_IN, usbnet_rx_isr, host_dev); if (!wireless_dev[usb_id].epin_buf) { wireless_dev[usb_id].epin_buf = usb_h_alloc_ep_buffer(usb_id, wireless_dev[usb_id].host_epin | USB_DIR_IN, wireless_dev[usb_id].rxmaxp * 2); } if (!wireless_dev[usb_id].inbuf) { wireless_dev[usb_id].inbuf = malloc(wireless_dev[usb_id].rxmaxp); } usb_write_rxfuncaddr(usb_id, wireless_dev[usb_id].host_epin, host_dev->private_data.devnum); usb_h_ep_config(usb_id, wireless_dev[usb_id].host_epin | USB_DIR_IN, USB_ENDPOINT_XFER_BULK, 1, rx_interval, wireless_dev[usb_id].epin_buf, wireless_dev[usb_id].rxmaxp); if (!wireless_dev[usb_id].epout_buf) { wireless_dev[usb_id].epout_buf = usb_h_alloc_ep_buffer(usb_id, wireless_dev[usb_id].host_epout | USB_DIR_OUT, wireless_dev[usb_id].txmaxp); } usb_write_txfuncaddr(usb_id, wireless_dev[usb_id].host_epout, host_dev->private_data.devnum); usb_h_ep_config(usb_id, wireless_dev[usb_id].host_epout | USB_DIR_OUT, USB_ENDPOINT_XFER_BULK, 0, 0, wireless_dev[usb_id].epout_buf, wireless_dev[usb_id].txmaxp); /* usb_h_ep_read_async(usb_id, wireless_dev[usb_id].host_epin, wireless_dev[usb_id].epin, NULL, 0, USB_ENDPOINT_XFER_BULK, 1); */ } return len; /* break; */ case USB_CDC_ETHERNET_TYPE: break; case USB_CDC_MDLM_TYPE: break; case USB_CDC_MDLM_DETAIL_TYPE: break; } next_desc: len += buf[0]; /* bLength */ buf += buf[0]; } return len; } /* * RPC done RNDIS-style. Caller guarantees: * -rndis_command message is properly byteswapped * - there's no other request pending * - buf can hold up to 1KB response (required by RNDIS spec) * On return, the first few entries are already byteswapped. * * Call context is likely probe(), before interface name is known, * which is why we won't try to use it in the diagnostics. */ int rndis_command(struct usb_host_device *device, struct rndis_msg_hdr *buf, int buflen) { int master_ifnum; int retval; int partial; unsigned count; __le32 rsp; static u32 xid = 0; u32 msg_len, request_id; /* REVISIT when this gets called from contexts other than probe() or * disconnect(): either serialize, or dispatch responses on xid */ /* Issue the request; xid is unique, don't bother byteswapping it */ if (likely(buf->msg_type != RNDIS_MSG_HALT && buf->msg_type != RNDIS_MSG_RESET)) { xid++; if (!xid) { xid++; } buf->request_id = (__le32) xid; } master_ifnum = 0;//info->control->cur_altsetting->desc.bInterfaceNumber;//控制接口描述符 retval = usb_control_msg(device, USB_CDC_SEND_ENCAPSULATED_COMMAND,//0x00 USB_TYPE_CLASS | USB_RECIP_INTERFACE,//0x21 0, master_ifnum, buf, le32_to_cpu(buf->msg_len) ); if (unlikely(retval < 0 || xid == 0)) { return retval; } /* Poll the control channel; the request probably completed immediately */ rsp = buf->msg_type | RNDIS_MSG_COMPLETION; for (count = 0; count < 10; count++) { memset(buf, 0, CONTROL_BUFFER_SIZE); retval = usb_control_msg(device, USB_CDC_GET_ENCAPSULATED_RESPONSE, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, master_ifnum, buf, buflen); if (likely(retval == 0)) { msg_len = le32_to_cpu(buf->msg_len); request_id = (u32) buf->request_id; if (likely(buf->msg_type == rsp)) { if (likely(request_id == xid)) { /* log_info( */ /* "rndis reply status %08x\n", */ /* le32_to_cpu(buf->status)); */ if (unlikely(rsp == RNDIS_MSG_RESET_C)) { return 0; } else if (unlikely(rsp == RNDIS_MSG_KEEPALIVE_C)) { log_info("RNDIS_MSG_KEEPALIVE_C"); return 0; } if (likely(RNDIS_STATUS_SUCCESS == buf->status)) { return 0; } return -EL3RST; } log_info( "rndis reply id %d expected %d", request_id, xid); /* then likely retry */ } else switch (buf->msg_type) { case RNDIS_MSG_INDICATE: /* fault/event */ //rndis_msg_indicate(dev, (void *)buf, buflen); log_info("RNDIS_MSG_INDICATE"); /* put_buf(buf, buflen); */ break; case RNDIS_MSG_KEEPALIVE: { /* ping */ struct rndis_keepalive_c *msg = (void *)buf; msg->msg_type = RNDIS_MSG_KEEPALIVE_C; msg->msg_len = cpu_to_le32(sizeof * msg); msg->status = RNDIS_STATUS_SUCCESS; retval = usb_control_msg(device, USB_CDC_SEND_ENCAPSULATED_COMMAND, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, master_ifnum, msg, sizeof * msg ); if (unlikely(retval < 0)) log_info( "rndis keepalive err %d", retval); } break; default: log_info( "unexpected rndis msg %08x len %d", le32_to_cpu(buf->msg_type), msg_len); break; } } else { /* device probably issued a protocol stall; ignore */ log_error("rndis response error, code %d\n", retval); } msleep(20); } log_error("rndis response timeout\n"); return -ETIMEDOUT; } /* * rndis_query: * * Performs a query for @oid along with 0 or more bytes of payload as * specified by @in_len. If @reply_len is not set to -1 then the reply * length is checked against this value, resulting in an error if it * doesn't match. * * NOTE: Adding a payload exactly or greater than the size of the expected * response payload is an evident requirement MSFT added for ActiveSync. * * The only exception is for OIDs that return a variably sized response, * in which case no payload should be added. This undocumented (and * nonsensical!) issue was found by sniffing protocol requests from the * ActiveSync 4.1 Windows driver. */ static int rndis_query(struct usb_host_device *device, void *buf, __le32 oid, u32 in_len, void **reply, int *reply_len) { int retval; union { void *buf; struct rndis_msg_hdr *header; struct rndis_query *get; struct rndis_query_c *get_c; } u; u32 off, len; u.buf = buf; memset(u.get, 0, sizeof * u.get + in_len); u.get->msg_type = RNDIS_MSG_QUERY; u.get->msg_len = cpu_to_le32(sizeof * u.get + in_len); u.get->oid = oid; u.get->len = cpu_to_le32(in_len); u.get->offset = cpu_to_le32(20); /* put_buf((u8*)u.header,u.header->msg_len); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); if (unlikely(retval < 0)) { log_error("RNDIS_MSG_QUERY(0x%08x) failed, %d\n", oid, retval); return retval; } off = le32_to_cpu(u.get_c->offset); len = le32_to_cpu(u.get_c->len); if (unlikely((8 + off + len) > CONTROL_BUFFER_SIZE)) { goto response_error; } if (*reply_len != -1 && len != *reply_len) { goto response_error; } *reply = (unsigned char *) &u.get_c->request_id + off; *reply_len = len; return retval; response_error: log_error("RNDIS_MSG_QUERY(0x%08x) " "invalid response - off %d len %d\n", oid, off, len); return -EDOM; } int generic_rndis_bind(struct usb_host_device *device, int flags) { int retval; union { void *buf; struct rndis_msg_hdr *header; struct rndis_init *init; struct rndis_init_c *init_c; struct rndis_query *get; struct rndis_query_c *get_c; struct rndis_set *set; struct rndis_set_c *set_c; struct rndis_halt *halt; struct rndis_keepalive *alive; struct rndis_keepalive_c *alive_c; } u; u32 tmp; __le32 phym_unspec, *phym, *conn_status = NULL; int reply_len; unsigned char *bp; /* we can't rely on i/o from stack working, or stack allocation */ u.buf = malloc(CONTROL_BUFFER_SIZE); if (!u.buf) { return -ENOMEM; } //retval = usbnet_generic_cdc_bind(dev, intf); u.init->msg_type = RNDIS_MSG_INIT; u.init->msg_len = cpu_to_le32(sizeof * u.init); u.init->major_version = cpu_to_le32(1); u.init->minor_version = cpu_to_le32(0); u.init->max_transfer_size = 0x4000; retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); if (unlikely(retval < 0)) { /* it might not even be an RNDIS device!! */ log_error("RNDIS init failed, %d\n", retval); goto fail_and_release; } log_info("RNDIS_MSG_INIT_C:\r\n \ status = %d\r\n \ major_version = %d\r\n \ minor_version = %d\r\n \ device_flags = %d\r\n \ medium = %d\r\n \ max_packets_per_message = %d\r\n \ max_transfer_size = %d\r\n \ packet_alignment = %d\r\n \ af_list_offset = %d\r\n \ af_list_size = %d\n", \ u.init_c->status, u.init_c->major_version, u.init_c->minor_version, u.init_c->device_flags, u.init_c->medium, \ u.init_c->max_packets_per_message, u.init_c->max_transfer_size, u.init_c->packet_alignment, \ u.init_c->af_list_offset, u.init_c->af_list_size); tmp = le32_to_cpu(u.init_c->max_transfer_size); #if 0 if (tmp < dev->hard_mtu) { if (tmp <= net->hard_header_len) { log_info( "dev can't take %u byte packets (max %u)\n", dev->hard_mtu, tmp); retval = -EINVAL; goto halt_fail_and_release; } dev_warn( "dev can't take %u byte packets (max %u), " "adjusting MTU to %u\n", dev->hard_mtu, tmp, tmp - net->hard_header_len); dev->hard_mtu = tmp; net->mtu = dev->hard_mtu - net->hard_header_len; } /* REVISIT: peripheral "alignment" request is ignored ... */ log_info( "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n", dev->hard_mtu, tmp, dev->rx_urb_size, 1 << le32_to_cpu(u.init_c->packet_alignment)); /* module has some device initialization code needs to be done right * after RNDIS_INIT */ if (dev->driver_info->early_init && dev->driver_info->early_init(dev) != 0) { goto halt_fail_and_release; } /* Check physical medium */ #endif phym = NULL; reply_len = sizeof * phym; retval = rndis_query(device, u.buf, OID_GEN_PHYSICAL_MEDIUM, 0, (void **) &phym, &reply_len); log_info("QUERY->OID_GEN_PHYSICAL_MEDIUM, retval = %d, phym = %x", retval, *phym); if (retval != 0 || !phym) { /* OID is optional so don't fail here. */ phym_unspec = RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED; phym = &phym_unspec; } if ((flags & FLAG_RNDIS_PHYM_WIRELESS) && *phym != RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) { log_error("driver requires wireless physical medium, but device is not\n"); retval = -ENODEV; goto halt_fail_and_release; } if ((flags & FLAG_RNDIS_PHYM_NOT_WIRELESS) && *phym == RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) { log_error("driver requires non-wireless physical medium, but device is wireless\n"); retval = -ENODEV; goto halt_fail_and_release; } reply_len = sizeof * phym; retval = rndis_query(device, u.buf, OID_GEN_MEDIA_CONNECT_STATUS, 0, (void **)&conn_status, &reply_len); log_info("QUERY->OID_GEN_MEDIA_CONNECT_STATUS, retval = %d, conn_status = %x", retval, *conn_status); reply_len = ETH_ALEN; retval = rndis_query(device, u.buf, OID_802_3_CURRENT_ADDRESS, 48, (void **) &bp, &reply_len); log_info("QUERY->OID_802_3_CURRENT_ADDRESS, retval = %d: \ addr = [%X:%X:%X:%X:%X:%X]", retval, bp[0], bp[1], bp[2], bp[3], bp[4], bp[5]); /* Get designated host ethernet address */ reply_len = ETH_ALEN; retval = rndis_query(device, u.buf, OID_802_3_PERMANENT_ADDRESS, 48, (void **) &bp, &reply_len); if (unlikely(retval < 0)) { log_error("rndis get ethaddr, %d\n", retval); goto halt_fail_and_release; } log_info("QUERY->OID_802_3_PERMANENT_ADDRESS: \ addr = [%X:%X:%X:%X:%X:%X]", bp[0], bp[1], bp[2], bp[3], bp[4], bp[5]); copy_usbnet_mac_addr(bp); #if 0 memcpy(net->dev_addr, bp, ETH_ALEN); memcpy(net->perm_addr, bp, ETH_ALEN); #endif /* set a nonzero filter to enable data transfers */ #if 0 memset(u.set, 0, sizeof * u.set); u.set->msg_type = RNDIS_MSG_SET; u.set->msg_len = cpu_to_le32(4 + sizeof * u.set); u.set->oid = OID_GEN_CURRENT_PACKET_FILTER; u.set->len = cpu_to_le32(4); u.set->offset = cpu_to_le32((sizeof * u.set) - 8); *(__le32 *)(u.buf + sizeof * u.set) = RNDIS_DEFAULT_FILTER; /* put_buf((u8*)u.header,u.header->msg_len); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->RNDIS_DEFAULT_FILTER:\r\n \ status = %d\n", u.set_c->status); if (unlikely(retval < 0)) { log_info("rndis set packet filter, %d\n", retval); goto halt_fail_and_release; } #else //////////////////////////////////////////////////////// memset(u.set, 0, sizeof * u.set); u.set->msg_type = RNDIS_MSG_SET; u.set->msg_len = cpu_to_le32(4 + sizeof * u.set); u.set->oid = OID_GEN_CURRENT_PACKET_FILTER; u.set->len = cpu_to_le32(4); u.set->offset = cpu_to_le32((sizeof * u.set) - 8); *(__le32 *)(u.buf + sizeof * u.set) = cpu_to_le32(0x03); /* put_buf(u.set, 4 + sizeof * u.set); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->RNDIS_DEFAULT_FILTER, 0x03: retval = %d", retval); u8 val[6] = {0x33, 0x33, 0x00, 0x00, 0x00, 0x01}; memset(u.set, 0, sizeof * u.set); u.set->msg_type = RNDIS_MSG_SET; u.set->msg_len = cpu_to_le32(6 + sizeof * u.set); u.set->oid = OID_802_3_MULTICAST_LIST; u.set->len = cpu_to_le32(6); u.set->offset = cpu_to_le32((sizeof * u.set) - 8); memcpy((__le32 *)(u.buf + sizeof * u.set), val, 6); /* put_buf(u.set, 6 + sizeof * u.set); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->OID_802_3_MULTICAST_LIST: retval = %d", retval); memset(u.set, 0, sizeof * u.set); u.set->msg_type = RNDIS_MSG_SET; u.set->msg_len = cpu_to_le32(4 + sizeof * u.set); u.set->oid = OID_GEN_CURRENT_PACKET_FILTER; u.set->len = cpu_to_le32(4); u.set->offset = cpu_to_le32((sizeof * u.set) - 8); *(__le32 *)(u.buf + sizeof * u.set) = cpu_to_le32(0x07); /* put_buf(u.set, 4 + sizeof * u.set); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->RNDIS_DEFAULT_FILTER, 0x07: retval = %d", retval); memset(u.set, 0, sizeof * u.set); u.set->msg_type = RNDIS_MSG_SET; u.set->msg_len = cpu_to_le32(4 + sizeof * u.set); u.set->oid = OID_GEN_CURRENT_PACKET_FILTER; u.set->len = cpu_to_le32(4); u.set->offset = cpu_to_le32((sizeof * u.set) - 8); *(__le32 *)(u.buf + sizeof * u.set) = cpu_to_le32(0x0f); /* put_buf(u.set, 4 + sizeof * u.set); */ retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->RNDIS_DEFAULT_FILTER, 0x0f: retval = %d", retval); #endif memset(u.alive, 0, sizeof * u.alive); u.alive->msg_type = RNDIS_MSG_KEEPALIVE; u.alive->msg_len = cpu_to_le32(sizeof * u.alive); retval = rndis_command(device, u.header, CONTROL_BUFFER_SIZE); log_info("SET->RNDIS_MSG_KEEPALIVE, retval = %d", retval); /* thread_fork("keepalive_period_task", 6, 512, 0, NULL, keepalive_period_task, NULL); */ //////////////////////////////////////////////////////// retval = 0; free(u.buf); return retval; halt_fail_and_release: memset(u.halt, 0, sizeof * u.halt); u.halt->msg_type = RNDIS_MSG_HALT; u.halt->msg_len = cpu_to_le32(sizeof * u.halt); (void) rndis_command(device, (void *)u.halt, CONTROL_BUFFER_SIZE); fail_and_release: /* usb_set_intfdata(info->data, NULL); */ /* usb_driver_release_interface(driver_of(intf), info->data); */ /* info->data = NULL; */ fail: free(u.buf); return retval; } #if 0 static void keepalive_period_task(void *priv) { int retval = 0; struct usb_host_device *host_dev = host_id2device(0); union { void *buf; struct rndis_msg_hdr *header; struct rndis_keepalive *alive; struct rndis_keepalive_c *alive_c; } u; u.buf = malloc(CONTROL_BUFFER_SIZE); for (;;) { memset(u.alive, 0, sizeof * u.alive); u.alive->msg_type = RNDIS_MSG_KEEPALIVE; u.alive->msg_len = cpu_to_le32(sizeof * u.alive); retval = rndis_command(host_dev, u.header, CONTROL_BUFFER_SIZE); log_info("%s, retval = %d\n", __FUNCTION__, retval); os_time_dly(100); } } #endif #endif