2 * carl9170 firmware - used by the ar9170 wireless device
6 * Copyright (c) 2000-2005 ZyDAS Technology Corporation
7 * Copyright (c) 2007-2009 Atheros Communications, Inc.
8 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
9 * Copyright 2009-2011 Christian Lamparter <chunkeey@googlemail.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
31 * NB: The firmware has to write into these structures
32 * so don't try to make them "const".
35 static struct ar9170_usb_config usb_config_highspeed = {
37 .bLength = USB_DT_CONFIG_SIZE,
38 .bDescriptorType = USB_DT_CONFIG,
39 .wTotalLength = cpu_to_le16(sizeof(usb_config_highspeed)),
41 .bConfigurationValue = 1,
43 .bmAttributes = USB_CONFIG_ATT_ONE |
44 #ifdef CONFIG_CARL9170FW_WOL
45 USB_CONFIG_ATT_WAKEUP |
46 #endif /* CONFIG_CARL9170FW_WOL */
48 .bMaxPower = 0xfa, /* 500 mA */
52 .bLength = USB_DT_INTERFACE_SIZE,
53 .bDescriptorType = USB_DT_INTERFACE,
54 .bInterfaceNumber = 0,
55 .bAlternateSetting = 0,
56 .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP,
57 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
58 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC,
59 .bInterfaceProtocol = 0,
65 .bLength = USB_DT_ENDPOINT_SIZE,
66 .bDescriptorType = USB_DT_ENDPOINT,
67 .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX,
68 .bmAttributes = USB_ENDPOINT_XFER_BULK,
69 .wMaxPacketSize = cpu_to_le16(512),
74 .bLength = USB_DT_ENDPOINT_SIZE,
75 .bDescriptorType = USB_DT_ENDPOINT,
76 .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX,
77 .bmAttributes = USB_ENDPOINT_XFER_BULK,
78 .wMaxPacketSize = cpu_to_le16(512),
83 .bLength = USB_DT_ENDPOINT_SIZE,
84 .bDescriptorType = USB_DT_ENDPOINT,
85 .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ,
86 .bmAttributes = USB_ENDPOINT_XFER_INT,
87 .wMaxPacketSize = cpu_to_le16(64),
92 .bLength = USB_DT_ENDPOINT_SIZE,
93 .bDescriptorType = USB_DT_ENDPOINT,
94 .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD,
95 .bmAttributes = USB_ENDPOINT_XFER_INT,
96 .wMaxPacketSize = cpu_to_le16(64),
102 static struct ar9170_usb_config usb_config_fullspeed = {
104 .bLength = USB_DT_CONFIG_SIZE,
105 .bDescriptorType = USB_DT_CONFIG,
106 .wTotalLength = cpu_to_le16(sizeof(usb_config_fullspeed)),
108 .bConfigurationValue = 1,
110 .bmAttributes = USB_CONFIG_ATT_ONE |
111 #ifdef CONFIG_CARL9170FW_WOL
112 USB_CONFIG_ATT_WAKEUP |
113 #endif /* CONFIG_CARL9170FW_WOL */
115 .bMaxPower = 0xfa, /* 500 mA */
119 .bLength = USB_DT_INTERFACE_SIZE,
120 .bDescriptorType = USB_DT_INTERFACE,
121 .bInterfaceNumber = 0,
122 .bAlternateSetting = 0,
123 .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP,
124 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
125 .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC,
126 .bInterfaceProtocol = 0,
132 .bLength = USB_DT_ENDPOINT_SIZE,
133 .bDescriptorType = USB_DT_ENDPOINT,
134 .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX,
135 .bmAttributes = USB_ENDPOINT_XFER_BULK,
136 .wMaxPacketSize = cpu_to_le16(64),
141 .bLength = USB_DT_ENDPOINT_SIZE,
142 .bDescriptorType = USB_DT_ENDPOINT,
143 .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX,
144 .bmAttributes = USB_ENDPOINT_XFER_BULK,
145 .wMaxPacketSize = cpu_to_le16(64),
150 .bLength = USB_DT_ENDPOINT_SIZE,
151 .bDescriptorType = USB_DT_ENDPOINT,
152 .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ,
153 .bmAttributes = USB_ENDPOINT_XFER_INT,
154 .wMaxPacketSize = cpu_to_le16(64),
159 .bLength = USB_DT_ENDPOINT_SIZE,
160 .bDescriptorType = USB_DT_ENDPOINT,
161 .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD,
162 .bmAttributes = USB_ENDPOINT_XFER_INT,
163 .wMaxPacketSize = cpu_to_le16(64),
169 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
170 static void usb_reset_eps(void)
174 /* clear all EPs' toggle bit */
175 for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) {
176 usb_set_input_ep_toggle(i);
177 usb_clear_input_ep_toggle(i);
178 usb_clear_input_ep_stall(i);
182 * NB: I've no idea why this cannot be integrated into the
185 for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) {
186 usb_set_output_ep_toggle(i);
187 usb_clear_output_ep_toggle(i);
188 usb_clear_output_ep_stall(i);
191 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
194 static void usb_pta_init(void)
196 unsigned int usb_dma_ctrl = 0;
197 /* Set PTA mode to USB */
198 andl(AR9170_PTA_REG_DMA_MODE_CTRL,
199 ~AR9170_PTA_DMA_MODE_CTRL_DISABLE_USB);
201 /* Do a software reset to PTA component */
202 orl(AR9170_PTA_REG_DMA_MODE_CTRL, AR9170_PTA_DMA_MODE_CTRL_RESET);
203 andl(AR9170_PTA_REG_DMA_MODE_CTRL, ~AR9170_PTA_DMA_MODE_CTRL_RESET);
205 if (usb_detect_highspeed()) {
206 fw.usb.os_cfg_desc = &usb_config_fullspeed;
207 fw.usb.cfg_desc = &usb_config_highspeed;
209 /* 512 Byte DMA transfers */
210 usb_dma_ctrl |= AR9170_USB_DMA_CTL_HIGH_SPEED;
212 fw.usb.cfg_desc = &usb_config_fullspeed;
213 fw.usb.os_cfg_desc = &usb_config_highspeed;
216 #ifdef CONFIG_CARL9170FW_USB_UP_STREAM
217 # if (CONFIG_CARL9170FW_RX_FRAME_LEN == 4096)
218 usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_4K;
219 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 8192)
220 usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_8K;
221 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 16384)
222 usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_16K;
223 # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 32768)
224 usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_32K;
226 # error "Invalid AR9170_RX_FRAME_LEN setting"
229 #else /* CONFIG_CARL9170FW_USB_UP_STREAM */
230 usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_PACKET_MODE;
231 #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */
233 #ifdef CONFIG_CARL9170FW_USB_DOWN_STREAM
234 /* Enable down stream mode */
235 usb_dma_ctrl |= AR9170_USB_DMA_CTL_DOWN_STREAM;
236 #endif /* CONFIG_CARL9170FW_USB_DOWN_STREAM */
238 #ifdef CONFIG_CARL9170FW_USB_UP_STREAM
239 /* Set the up stream mode maximum aggregate number */
240 set(AR9170_USB_REG_MAX_AGG_UPLOAD, 4);
243 * Set the up stream mode timeout value.
244 * NB: The vendor driver (otus) set 0x80?
246 set(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80);
247 #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */
249 /* Enable up stream and down stream */
250 usb_dma_ctrl |= AR9170_USB_DMA_CTL_ENABLE_TO_DEVICE |
251 AR9170_USB_DMA_CTL_ENABLE_FROM_DEVICE;
253 set(AR9170_USB_REG_DMA_CTL, usb_dma_ctrl);
262 * The fw structure is always initialized with "0"
263 * during boot(); No need to waste precious bytes here.
265 * fw.usb.interface_setting = 0;
266 * fw.usb.alternate_interface_setting = 0;
267 * fw.usb.device_feature = 0;
270 #ifdef CONFIG_CARL9170FW_WOL
271 fw.usb.device_feature |= USB_DEVICE_REMOTE_WAKEUP;
272 usb_enable_remote_wakeup();
273 #endif /* CONFIG_CARL9170FW_WOL */
276 #define GET_ARRAY(a, o) ((uint32_t *) (((unsigned long) data) + offset))
278 static void usb_ep0rx_data(const void *data, const unsigned int len)
283 BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
284 BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
286 for (offset = 0; offset < ((len + 3) & ~3); offset += 4) {
287 value = get(AR9170_USB_REG_EP0_DATA);
288 memcpy(GET_ARRAY(data, offset), &value,
289 min(len - offset, (unsigned int)4));
293 static int usb_ep0tx_data(const void *data, const unsigned int len)
295 unsigned int offset = 0, block, last_block = 0;
298 BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
299 BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX);
301 block = min(len, (unsigned int) 4);
303 while (offset < len) {
305 if (last_block != block || block < 4)
306 setb(AR9170_USB_REG_FIFO_SIZE, (1 << block) - 1);
308 memcpy(&value, GET_ARRAY(data, offset), block);
310 set(AR9170_USB_REG_EP0_DATA, value);
313 last_block = block = min(len - offset, (unsigned int) 4);
316 setb(AR9170_USB_REG_FIFO_SIZE, 0xf);
318 /* this will push the data to the host */
323 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
324 static int usb_get_status(const struct usb_ctrlrequest *ctrl)
326 __le16 status = cpu_to_le16(fw.usb.device_feature);
328 if ((ctrl->bRequestType & USB_DIR_MASK) != USB_DIR_IN)
331 switch (ctrl->bRequestType & USB_RECIP_MASK) {
332 case USB_RECIP_DEVICE:
333 status &= cpu_to_le16(~USB_DEVICE_SELF_POWERED);
334 status &= cpu_to_le16(~USB_DEVICE_REMOTE_WAKEUP);
337 case USB_RECIP_INTERFACE:
338 /* USB spec: This is reserved for future use. */
339 status = cpu_to_le16(0);
342 case USB_RECIP_ENDPOINT: {
343 unsigned int ep = le16_to_cpu(ctrl->wIndex) & 0xf;
344 unsigned int dir = le16_to_cpu(ctrl->wIndex) & USB_DIR_MASK;
347 status = !!(getb(AR9170_USB_REG_CX_CONFIG_STATUS) & BIT(2));
351 if (dir == USB_DIR_IN)
352 addr = AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH;
354 addr = AR9170_USB_REG_EP_OUT_MAX_SIZE_HIGH;
359 * AR9170_USB_EP_OUT_STALL == AR9170_USB_EP_IN_STALL
360 * so it doesn't matter which one we use
362 status = !!(getb(addr) & AR9170_USB_EP_OUT_STALL);
366 case USB_RECIP_OTHER:
371 return usb_ep0tx_data((const void *) &status, sizeof(status));
374 static int usb_get_string_desc(const struct usb_ctrlrequest *ctrl)
376 const struct usb_string_descriptor *string_desc = NULL;
378 switch (le16_to_cpu(ctrl->wValue) & 0xff) {
380 string_desc = (const struct usb_string_descriptor *)
381 rom.hw.usb.string0_desc;
385 string_desc = (const struct usb_string_descriptor *)
386 rom.hw.usb.string1_desc;
390 string_desc = (const struct usb_string_descriptor *)
391 rom.hw.usb.string2_desc;
395 string_desc = (const struct usb_string_descriptor *)
396 rom.hw.usb.string3_desc;
404 return usb_ep0tx_data(string_desc, string_desc->bLength);
409 static int usb_get_device_desc(const struct usb_ctrlrequest *ctrl __unused)
411 return usb_ep0tx_data(&rom.hw.usb.device_desc,
412 rom.hw.usb.device_desc.bLength);
415 static int usb_get_config_desc(const struct usb_ctrlrequest *ctrl __unused)
417 fw.usb.cfg_desc->cfg.bDescriptorType = USB_DT_CONFIG;
419 return usb_ep0tx_data(fw.usb.cfg_desc,
420 le16_to_cpu(fw.usb.cfg_desc->cfg.wTotalLength));
423 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
424 static int usb_get_otherspeed_desc(const struct usb_ctrlrequest *ctrl __unused)
427 fw.usb.os_cfg_desc->cfg.bDescriptorType = USB_DT_OTHER_SPEED_CONFIG;
429 return usb_ep0tx_data(fw.usb.os_cfg_desc,
430 le16_to_cpu(fw.usb.os_cfg_desc->cfg.wTotalLength));
432 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
434 static int usb_get_qualifier_desc(const struct usb_ctrlrequest *ctrl __unused)
436 struct usb_qualifier_descriptor qual;
439 * The qualifier descriptor shares some structural details
440 * with the main device descriptor.
443 memcpy(&qual, &rom.hw.usb.device_desc, sizeof(qual));
445 /* (Re)-Initialize fields */
446 qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
447 qual.bLength = sizeof(qual);
448 qual.bNumConfigurations = rom.hw.usb.device_desc.bNumConfigurations;
451 return usb_ep0tx_data(&qual, qual.bLength);
454 #define USB_CHECK_REQTYPE(ctrl, recip, dir) \
455 (((ctrl->bRequestType & USB_RECIP_MASK) != recip) || \
456 ((ctrl->bRequestType & USB_DIR_MASK) != dir))
458 static int usb_get_descriptor(const struct usb_ctrlrequest *ctrl)
462 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN))
465 switch (le16_to_cpu(ctrl->wValue) >> 8) {
467 status = usb_get_device_desc(ctrl);
471 status = usb_get_config_desc(ctrl);
475 status = usb_get_string_desc(ctrl);
478 case USB_DT_INTERFACE:
481 case USB_DT_ENDPOINT:
484 case USB_DT_DEVICE_QUALIFIER:
485 status = usb_get_qualifier_desc(ctrl);
488 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
489 case USB_DT_OTHER_SPEED_CONFIG:
490 status = usb_get_otherspeed_desc(ctrl);
492 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
501 static int usb_get_configuration(const struct usb_ctrlrequest *ctrl)
503 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN))
506 return usb_ep0tx_data(&fw.usb.config, 1);
509 static int usb_set_configuration(const struct usb_ctrlrequest *ctrl)
513 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT))
516 config = le16_to_cpu(ctrl->wValue);
520 andb(AR9170_USB_REG_DEVICE_ADDRESS,
521 (uint8_t) ~(AR9170_USB_DEVICE_ADDRESS_CONFIGURE));
522 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
524 fw.usb.config = config;
526 if (usb_detect_highspeed()) {
527 /* High Speed Configuration */
528 usb_init_highspeed_fifo_cfg();
530 /* Full Speed Configuration */
531 usb_init_fullspeed_fifo_cfg();
538 /* usb_pta_init() ? */
541 orb(AR9170_USB_REG_DEVICE_ADDRESS,
542 (AR9170_USB_DEVICE_ADDRESS_CONFIGURE));
544 usb_enable_global_int();
551 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
554 static int usb_set_address(const struct usb_ctrlrequest *ctrl)
556 unsigned int address;
558 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT))
561 address = le16_to_cpu(ctrl->wValue);
564 * The original firmware used 0x100 (which is, of course,
565 * too big to fit into uint8_t).
566 * However based on the available information (hw.h), BIT(7)
567 * is used as some sort of flag and should not be
568 * part of the device address.
570 if (address >= BIT(7))
573 setb(AR9170_USB_REG_DEVICE_ADDRESS, (uint8_t) address);
577 static int usb_get_interface(const struct usb_ctrlrequest *ctrl)
579 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_IN))
582 if (usb_configured() == false)
585 switch (fw.usb.config) {
593 return usb_ep0tx_data(&fw.usb.alternate_interface_setting, 1);
596 static int usb_manipulate_feature(const struct usb_ctrlrequest *ctrl, bool __unused clear)
598 unsigned int feature;
600 if ((ctrl->bRequestType & USB_DIR_MASK) != USB_DIR_OUT)
603 if (usb_configured() == false)
606 feature = le16_to_cpu(ctrl->wValue);
608 switch (ctrl->bRequestType & USB_RECIP_MASK) {
609 case USB_RECIP_DEVICE: {
610 #ifdef CONFIG_CARL9170FW_WOL
611 if (feature & USB_DEVICE_REMOTE_WAKEUP) {
613 usb_disable_remote_wakeup();
615 usb_enable_remote_wakeup();
617 #endif /* CONFIG_CARL9170FW_WOL */
620 fw.usb.device_feature &= ~feature;
622 fw.usb.device_feature |= feature;
628 case USB_RECIP_ENDPOINT: {
629 unsigned int ep, dir;
631 ep = le16_to_cpu(ctrl->wIndex) & 0xf;
632 dir = le16_to_cpu(ctrl->wIndex) & USB_DIR_MASK;
634 /* According to the spec, EP cannot be stopped this way. */
639 if (dir == USB_DIR_IN)
640 addr = AR9170_USB_REG_EP_IN_MAX_SIZE_HIGH;
642 addr = AR9170_USB_REG_EP_OUT_MAX_SIZE_HIGH;
647 andb(addr, ~AR9170_USB_EP_OUT_STALL);
649 orb(addr, AR9170_USB_EP_OUT_STALL);
654 case USB_RECIP_INTERFACE:
656 * the current USB Specification Revision 2
657 * specifies no interface features.
667 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
668 static int usb_set_interface(const struct usb_ctrlrequest *ctrl)
670 unsigned int intf, alt_intf;
671 if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_OUT))
674 if (usb_configured() == false)
677 intf = le16_to_cpu(ctrl->wIndex);
678 alt_intf = le16_to_cpu(ctrl->wValue);
682 if (alt_intf != fw.usb.cfg_desc->intf.bAlternateSetting)
685 fw.usb.interface_setting = (uint8_t) intf;
686 fw.usb.alternate_interface_setting = (uint8_t) alt_intf;
687 if (usb_detect_highspeed())
688 usb_init_highspeed_fifo_cfg();
690 usb_init_fullspeed_fifo_cfg();
693 usb_enable_global_int();
701 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
702 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
704 static int usb_standard_command(const struct usb_ctrlrequest *ctrl __unused)
708 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
709 switch (ctrl->bRequest) {
710 case USB_REQ_GET_STATUS:
711 status = usb_get_status(ctrl);
714 case USB_REQ_CLEAR_FEATURE:
715 case USB_REQ_SET_FEATURE:
716 status = usb_manipulate_feature(ctrl, ctrl->bRequest == USB_REQ_CLEAR_FEATURE);
719 case USB_REQ_SET_ADDRESS:
720 status = usb_set_address(ctrl);
723 case USB_REQ_GET_DESCRIPTOR:
724 status = usb_get_descriptor(ctrl);
727 case USB_REQ_SET_DESCRIPTOR:
730 case USB_REQ_GET_CONFIGURATION:
731 status = usb_get_configuration(ctrl);
734 case USB_REQ_SET_CONFIGURATION:
735 status = usb_set_configuration(ctrl);
738 case USB_REQ_GET_INTERFACE:
739 status = usb_get_interface(ctrl);
742 case USB_REQ_SET_INTERFACE:
743 #ifdef CONFIG_CARL9170FW_USB_MODESWITCH
744 status = usb_set_interface(ctrl);
745 #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */
748 case USB_REQ_SYNCH_FRAME:
755 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
760 static int usb_class_command(const struct usb_ctrlrequest *ctrl __unused)
765 static int usb_vendor_command(const struct usb_ctrlrequest *ctrl __unused)
768 * Note: Firmware upload/boot is not implemented.
769 * It's impossible to replace the current image
776 #undef USB_CHECK_TYPE
778 void usb_ep0setup(void)
780 struct usb_ctrlrequest ctrl;
782 usb_ep0rx_data(&ctrl, sizeof(ctrl));
784 switch (ctrl.bRequestType & USB_TYPE_MASK) {
785 case USB_TYPE_STANDARD:
786 status = usb_standard_command(&ctrl);
790 status = usb_class_command(&ctrl);
793 case USB_TYPE_VENDOR:
794 status = usb_vendor_command(&ctrl);
803 fw.usb.ep0_action |= CARL9170_EP0_STALL;
804 #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS
806 fw.usb.ep0_action |= CARL9170_EP0_TRIGGER;
807 #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */
812 if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len))
815 usb_ep0rx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len);
816 fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len;
821 if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len))
824 usb_ep0tx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len);
825 fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len;