| /* |
| * carl9170 firmware - used by the ar9170 wireless device |
| * |
| * USB Controller |
| * |
| * Copyright (c) 2000-2005 ZyDAS Technology Corporation |
| * Copyright (c) 2007-2009 Atheros Communications, Inc. |
| * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> |
| * Copyright 2009-2011 Christian Lamparter <chunkeey@googlemail.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| */ |
| #include "carl9170.h" |
| #include "usb.h" |
| #include "printf.h" |
| #include "rom.h" |
| |
| /* |
| * NB: The firmware has to write into these structures |
| * so don't try to make them "const". |
| */ |
| |
| static struct ar9170_usb_config usb_config_highspeed = { |
| .cfg = { |
| .bLength = USB_DT_CONFIG_SIZE, |
| .bDescriptorType = USB_DT_CONFIG, |
| .wTotalLength = cpu_to_le16(sizeof(usb_config_highspeed)), |
| .bNumInterfaces = 1, |
| .bConfigurationValue = 1, |
| .iConfiguration = 0, |
| .bmAttributes = USB_CONFIG_ATT_ONE | |
| #ifdef CONFIG_CARL9170FW_WOL |
| USB_CONFIG_ATT_WAKEUP | |
| #endif /* CONFIG_CARL9170FW_WOL */ |
| 0, |
| .bMaxPower = 0xfa, /* 500 mA */ |
| }, |
| |
| .intf = { |
| .bLength = USB_DT_INTERFACE_SIZE, |
| .bDescriptorType = USB_DT_INTERFACE, |
| .bInterfaceNumber = 0, |
| .bAlternateSetting = 0, |
| .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP, |
| .bInterfaceClass = USB_CLASS_VENDOR_SPEC, |
| .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC, |
| .bInterfaceProtocol = 0, |
| .iInterface = 0, |
| }, |
| |
| .ep = { |
| { /* EP 1 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| .wMaxPacketSize = cpu_to_le16(512), |
| .bInterval = 0, |
| }, |
| |
| { /* EP 2 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| .wMaxPacketSize = cpu_to_le16(512), |
| .bInterval = 0, |
| }, |
| |
| { /* EP 3 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ, |
| .bmAttributes = USB_ENDPOINT_XFER_INT, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 1, |
| }, |
| |
| { /* EP 4 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD, |
| .bmAttributes = USB_ENDPOINT_XFER_INT, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 1, |
| }, |
| }, |
| }; |
| |
| static struct ar9170_usb_config usb_config_fullspeed = { |
| .cfg = { |
| .bLength = USB_DT_CONFIG_SIZE, |
| .bDescriptorType = USB_DT_CONFIG, |
| .wTotalLength = cpu_to_le16(sizeof(usb_config_fullspeed)), |
| .bNumInterfaces = 1, |
| .bConfigurationValue = 1, |
| .iConfiguration = 0, |
| .bmAttributes = USB_CONFIG_ATT_ONE | |
| #ifdef CONFIG_CARL9170FW_WOL |
| USB_CONFIG_ATT_WAKEUP | |
| #endif /* CONFIG_CARL9170FW_WOL */ |
| 0, |
| .bMaxPower = 0xfa, /* 500 mA */ |
| }, |
| |
| .intf = { |
| .bLength = USB_DT_INTERFACE_SIZE, |
| .bDescriptorType = USB_DT_INTERFACE, |
| .bInterfaceNumber = 0, |
| .bAlternateSetting = 0, |
| .bNumEndpoints = AR9170_USB_NUM_EXTRA_EP, |
| .bInterfaceClass = USB_CLASS_VENDOR_SPEC, |
| .bInterfaceSubClass = USB_SUBCLASS_VENDOR_SPEC, |
| .bInterfaceProtocol = 0, |
| .iInterface = 0, |
| }, |
| |
| .ep = { |
| { /* EP 1 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_TX, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 0, |
| }, |
| |
| { /* EP 2 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_RX, |
| .bmAttributes = USB_ENDPOINT_XFER_BULK, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 0, |
| }, |
| |
| { /* EP 3 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_IN | AR9170_USB_EP_IRQ, |
| .bmAttributes = USB_ENDPOINT_XFER_INT, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 1, |
| }, |
| |
| { /* EP 4 */ |
| .bLength = USB_DT_ENDPOINT_SIZE, |
| .bDescriptorType = USB_DT_ENDPOINT, |
| .bEndpointAddress = USB_DIR_OUT | AR9170_USB_EP_CMD, |
| .bmAttributes = USB_ENDPOINT_XFER_INT, |
| .wMaxPacketSize = cpu_to_le16(64), |
| .bInterval = 1, |
| }, |
| }, |
| }; |
| |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| static void usb_reset_eps(void) |
| { |
| unsigned int i; |
| |
| /* clear all EPs' toggle bit */ |
| for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) { |
| usb_set_input_ep_toggle(i); |
| usb_clear_input_ep_toggle(i); |
| } |
| |
| /* |
| * NB: I've no idea why this cannot be integrated into the |
| * previous loop? |
| */ |
| for (i = 1; i < __AR9170_USB_NUM_MAX_EP; i++) { |
| usb_set_output_ep_toggle(i); |
| usb_clear_output_ep_toggle(i); |
| } |
| } |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| |
| |
| static void usb_pta_init(void) |
| { |
| unsigned int usb_dma_ctrl = 0; |
| /* Set PTA mode to USB */ |
| andl(AR9170_PTA_REG_DMA_MODE_CTRL, |
| ~AR9170_PTA_DMA_MODE_CTRL_DISABLE_USB); |
| |
| /* Do a software reset to PTA component */ |
| orl(AR9170_PTA_REG_DMA_MODE_CTRL, AR9170_PTA_DMA_MODE_CTRL_RESET); |
| andl(AR9170_PTA_REG_DMA_MODE_CTRL, ~AR9170_PTA_DMA_MODE_CTRL_RESET); |
| |
| if (usb_detect_highspeed()) { |
| fw.usb.os_cfg_desc = &usb_config_fullspeed; |
| fw.usb.cfg_desc = &usb_config_highspeed; |
| |
| /* 512 Byte DMA transfers */ |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_HIGH_SPEED; |
| } else { |
| fw.usb.cfg_desc = &usb_config_fullspeed; |
| fw.usb.os_cfg_desc = &usb_config_highspeed; |
| } |
| |
| #ifdef CONFIG_CARL9170FW_USB_UP_STREAM |
| # if (CONFIG_CARL9170FW_RX_FRAME_LEN == 4096) |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_4K; |
| # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 8192) |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_8K; |
| # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 16384) |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_16K; |
| # elif (CONFIG_CARL9170FW_RX_FRAME_LEN == 32768) |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_STREAM_32K; |
| # else |
| # error "Invalid AR9170_RX_FRAME_LEN setting" |
| # endif |
| |
| #else /* CONFIG_CARL9170FW_USB_UP_STREAM */ |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_UP_PACKET_MODE; |
| #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */ |
| |
| #ifdef CONFIG_CARL9170FW_USB_DOWN_STREAM |
| /* Enable down stream mode */ |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_DOWN_STREAM; |
| #endif /* CONFIG_CARL9170FW_USB_DOWN_STREAM */ |
| |
| #ifdef CONFIG_CARL9170FW_USB_UP_STREAM |
| /* Set the up stream mode maximum aggregate number */ |
| set(AR9170_USB_REG_MAX_AGG_UPLOAD, 4); |
| |
| /* |
| * Set the up stream mode timeout value. |
| * NB: The vendor driver (otus) set 0x80? |
| */ |
| set(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80); |
| #endif /* CONFIG_CARL9170FW_USB_UP_STREAM */ |
| |
| /* Enable up stream and down stream */ |
| usb_dma_ctrl |= AR9170_USB_DMA_CTL_ENABLE_TO_DEVICE | |
| AR9170_USB_DMA_CTL_ENABLE_FROM_DEVICE; |
| |
| set(AR9170_USB_REG_DMA_CTL, usb_dma_ctrl); |
| } |
| |
| void usb_init(void) |
| { |
| usb_pta_init(); |
| |
| fw.usb.config = 1; |
| /* |
| * The fw structure is always initialized with "0" |
| * during boot(); No need to waste precious bytes here. |
| * |
| * fw.usb.interface_setting = 0; |
| * fw.usb.alternate_interface_setting = 0; |
| * fw.usb.device_feature = 0; |
| */ |
| |
| #ifdef CONFIG_CARL9170FW_WOL |
| fw.usb.device_feature |= USB_DEVICE_REMOTE_WAKEUP; |
| usb_enable_remote_wakeup(); |
| #endif /* CONFIG_CARL9170FW_WOL */ |
| } |
| |
| #define GET_ARRAY(a, o) ((uint32_t *) (((unsigned long) data) + offset)) |
| |
| static void usb_ep0rx_data(const void *data, const unsigned int len) |
| { |
| unsigned int offset; |
| uint32_t value; |
| |
| BUG_ON(len > AR9170_USB_EP_CTRL_MAX); |
| BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX); |
| |
| for (offset = 0; offset < ((len + 3) & ~3); offset += 4) { |
| value = get(AR9170_USB_REG_EP0_DATA); |
| memcpy(GET_ARRAY(data, offset), &value, |
| min(len - offset, (unsigned int)4)); |
| } |
| } |
| |
| static int usb_ep0tx_data(const void *data, const unsigned int len) |
| { |
| unsigned int offset = 0, block, last_block = 0; |
| uint32_t value; |
| |
| BUG_ON(len > AR9170_USB_EP_CTRL_MAX); |
| BUILD_BUG_ON(len > AR9170_USB_EP_CTRL_MAX); |
| |
| block = min(len, (unsigned int) 4); |
| offset = 0; |
| while (offset < len) { |
| |
| if (last_block != block || block < 4) |
| setb(AR9170_USB_REG_FIFO_SIZE, (1 << block) - 1); |
| |
| memcpy(&value, GET_ARRAY(data, offset), block); |
| |
| set(AR9170_USB_REG_EP0_DATA, value); |
| |
| offset += block; |
| last_block = block = min(len - offset, (unsigned int) 4); |
| } |
| |
| setb(AR9170_USB_REG_FIFO_SIZE, 0xf); |
| |
| /* this will push the data to the host */ |
| return 1; |
| } |
| #undef GET_ARRAY |
| |
| #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS |
| static int usb_get_status(const struct usb_ctrlrequest *ctrl) |
| { |
| __le16 status = cpu_to_le16(fw.usb.device_feature); |
| |
| if ((ctrl->bRequestType & USB_DIR_MASK) != USB_DIR_IN) |
| return -1; |
| |
| switch (ctrl->bRequestType & USB_RECIP_MASK) { |
| case USB_RECIP_DEVICE: |
| status &= cpu_to_le16(~USB_DEVICE_SELF_POWERED); |
| status &= cpu_to_le16(~USB_DEVICE_REMOTE_WAKEUP); |
| break; |
| |
| case USB_RECIP_INTERFACE: |
| /* USB spec: This is reserved for future use. */ |
| status = cpu_to_le16(0); |
| break; |
| |
| case USB_RECIP_ENDPOINT: |
| case USB_RECIP_OTHER: |
| default: |
| break; |
| } |
| |
| return usb_ep0tx_data((const void *) &status, sizeof(status)); |
| } |
| |
| static int usb_get_string_desc(const struct usb_ctrlrequest *ctrl) |
| { |
| const struct usb_string_descriptor *string_desc = NULL; |
| |
| switch (le16_to_cpu(ctrl->wValue) & 0xff) { |
| case 0x00: |
| string_desc = (const struct usb_string_descriptor *) |
| rom.hw.usb.string0_desc; |
| break; |
| |
| case 0x10: |
| string_desc = (const struct usb_string_descriptor *) |
| rom.hw.usb.string1_desc; |
| break; |
| |
| case 0x20: |
| string_desc = (const struct usb_string_descriptor *) |
| rom.hw.usb.string2_desc; |
| break; |
| |
| case 0x30: |
| string_desc = (const struct usb_string_descriptor *) |
| rom.hw.usb.string3_desc; |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (string_desc) |
| return usb_ep0tx_data(string_desc, string_desc->bLength); |
| |
| return -1; |
| } |
| |
| static int usb_get_device_desc(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| return usb_ep0tx_data(&rom.hw.usb.device_desc, |
| rom.hw.usb.device_desc.bLength); |
| } |
| |
| static int usb_get_config_desc(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| fw.usb.cfg_desc->cfg.bDescriptorType = USB_DT_CONFIG; |
| |
| return usb_ep0tx_data(fw.usb.cfg_desc, |
| le16_to_cpu(fw.usb.cfg_desc->cfg.wTotalLength)); |
| } |
| |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| static int usb_get_otherspeed_desc(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| |
| fw.usb.os_cfg_desc->cfg.bDescriptorType = USB_DT_OTHER_SPEED_CONFIG; |
| |
| return usb_ep0tx_data(fw.usb.os_cfg_desc, |
| le16_to_cpu(fw.usb.os_cfg_desc->cfg.wTotalLength)); |
| } |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| |
| static int usb_get_qualifier_desc(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| struct usb_qualifier_descriptor qual; |
| |
| /* |
| * The qualifier descriptor shares some structural details |
| * with the main device descriptor. |
| */ |
| |
| memcpy(&qual, &rom.hw.usb.device_desc, sizeof(qual)); |
| |
| /* (Re)-Initialize fields */ |
| qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER; |
| qual.bLength = sizeof(qual); |
| qual.bNumConfigurations = rom.hw.usb.device_desc.bNumConfigurations; |
| qual.bRESERVED = 0; |
| |
| return usb_ep0tx_data(&qual, qual.bLength); |
| } |
| |
| #define USB_CHECK_REQTYPE(ctrl, recip, dir) \ |
| (((ctrl->bRequestType & USB_RECIP_MASK) != recip) || \ |
| ((ctrl->bRequestType & USB_DIR_MASK) != dir)) |
| |
| static int usb_get_descriptor(const struct usb_ctrlrequest *ctrl) |
| { |
| int status = -1; |
| |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN)) |
| return status; |
| |
| switch (le16_to_cpu(ctrl->wValue) >> 8) { |
| case USB_DT_DEVICE: |
| status = usb_get_device_desc(ctrl); |
| break; |
| |
| case USB_DT_CONFIG: |
| status = usb_get_config_desc(ctrl); |
| break; |
| |
| case USB_DT_STRING: |
| status = usb_get_string_desc(ctrl); |
| break; |
| |
| case USB_DT_INTERFACE: |
| break; |
| |
| case USB_DT_ENDPOINT: |
| break; |
| |
| case USB_DT_DEVICE_QUALIFIER: |
| status = usb_get_qualifier_desc(ctrl); |
| break; |
| |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| case USB_DT_OTHER_SPEED_CONFIG: |
| status = usb_get_otherspeed_desc(ctrl); |
| break; |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| default: |
| break; |
| |
| } |
| |
| return status; |
| } |
| |
| static int usb_get_configuration(const struct usb_ctrlrequest *ctrl) |
| { |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_IN)) |
| return -1; |
| |
| return usb_ep0tx_data(&fw.usb.config, 1); |
| } |
| |
| static int usb_set_configuration(const struct usb_ctrlrequest *ctrl) |
| { |
| unsigned int config; |
| |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT)) |
| return -1; |
| |
| config = le16_to_cpu(ctrl->wValue); |
| switch (config) { |
| case 0: |
| /* Disable Device */ |
| andb(AR9170_USB_REG_DEVICE_ADDRESS, |
| (uint8_t) ~(AR9170_USB_DEVICE_ADDRESS_CONFIGURE)); |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| case 1: |
| fw.usb.config = config; |
| |
| if (usb_detect_highspeed()) { |
| /* High Speed Configuration */ |
| usb_init_highspeed_fifo_cfg(); |
| } else { |
| /* Full Speed Configuration */ |
| usb_init_fullspeed_fifo_cfg(); |
| } |
| break; |
| |
| default: |
| return -1; |
| } |
| /* usb_pta_init() ? */ |
| |
| usb_reset_eps(); |
| orb(AR9170_USB_REG_DEVICE_ADDRESS, |
| (AR9170_USB_DEVICE_ADDRESS_CONFIGURE)); |
| |
| usb_enable_global_int(); |
| usb_trigger_out(); |
| return 1; |
| #else |
| default: |
| return -1; |
| } |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| } |
| |
| static int usb_set_address(const struct usb_ctrlrequest *ctrl) |
| { |
| unsigned int address; |
| |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT)) |
| return -1; |
| |
| address = le16_to_cpu(ctrl->wValue); |
| |
| /* |
| * The original firmware used 0x100 (which is, of course, |
| * too big to fit into uint8_t). |
| * However based on the available information (hw.h), BIT(7) |
| * is used as some sort of flag and should not be |
| * part of the device address. |
| */ |
| if (address >= BIT(7)) |
| return -1; |
| |
| setb(AR9170_USB_REG_DEVICE_ADDRESS, (uint8_t) address); |
| return 1; |
| } |
| |
| static int usb_get_interface(const struct usb_ctrlrequest *ctrl) |
| { |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_IN)) |
| return -1; |
| |
| if (usb_configured() == false) |
| return -1; |
| |
| switch (fw.usb.config) { |
| case 1: |
| break; |
| |
| default: |
| return -1; |
| } |
| |
| return usb_ep0tx_data(&fw.usb.alternate_interface_setting, 1); |
| } |
| |
| static int usb_manipulate_feature(const struct usb_ctrlrequest *ctrl, bool __unused clear) |
| { |
| unsigned int feature; |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_DEVICE, USB_DIR_OUT)) |
| return -1; |
| |
| if (usb_configured() == false) |
| return -1; |
| |
| feature = le16_to_cpu(ctrl->wValue); |
| |
| #ifdef CONFIG_CARL9170FW_WOL |
| if (feature & USB_DEVICE_REMOTE_WAKEUP) { |
| if (clear) |
| usb_disable_remote_wakeup(); |
| else |
| usb_enable_remote_wakeup(); |
| } |
| #endif /* CONFIG_CARL9170FW_WOL */ |
| |
| if (clear) |
| fw.usb.device_feature &= ~feature; |
| else |
| fw.usb.device_feature |= feature; |
| |
| return 1; |
| } |
| |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| static int usb_set_interface(const struct usb_ctrlrequest *ctrl) |
| { |
| unsigned int intf, alt_intf; |
| if (USB_CHECK_REQTYPE(ctrl, USB_RECIP_INTERFACE, USB_DIR_OUT)) |
| return -1; |
| |
| if (usb_configured() == false) |
| return -1; |
| |
| intf = le16_to_cpu(ctrl->wIndex); |
| alt_intf = le16_to_cpu(ctrl->wValue); |
| |
| switch (intf) { |
| case 0: |
| if (alt_intf != fw.usb.cfg_desc->intf.bAlternateSetting) |
| return -1; |
| |
| fw.usb.interface_setting = (uint8_t) intf; |
| fw.usb.alternate_interface_setting = (uint8_t) alt_intf; |
| if (usb_detect_highspeed()) |
| usb_init_highspeed_fifo_cfg(); |
| else |
| usb_init_fullspeed_fifo_cfg(); |
| |
| usb_reset_eps(); |
| usb_enable_global_int(); |
| usb_trigger_out(); |
| return 1; |
| |
| default: |
| return -1; |
| } |
| } |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */ |
| |
| static int usb_standard_command(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| int status = -1; |
| |
| #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS |
| switch (ctrl->bRequest) { |
| case USB_REQ_GET_STATUS: |
| status = usb_get_status(ctrl); |
| break; |
| |
| case USB_REQ_CLEAR_FEATURE: |
| case USB_REQ_SET_FEATURE: |
| usb_manipulate_feature(ctrl, ctrl->bRequest == USB_REQ_CLEAR_FEATURE); |
| break; |
| |
| case USB_REQ_SET_ADDRESS: |
| status = usb_set_address(ctrl); |
| break; |
| |
| case USB_REQ_GET_DESCRIPTOR: |
| status = usb_get_descriptor(ctrl); |
| break; |
| |
| case USB_REQ_SET_DESCRIPTOR: |
| break; |
| |
| case USB_REQ_GET_CONFIGURATION: |
| status = usb_get_configuration(ctrl); |
| break; |
| |
| case USB_REQ_SET_CONFIGURATION: |
| status = usb_set_configuration(ctrl); |
| break; |
| |
| case USB_REQ_GET_INTERFACE: |
| status = usb_get_interface(ctrl); |
| break; |
| |
| case USB_REQ_SET_INTERFACE: |
| #ifdef CONFIG_CARL9170FW_USB_MODESWITCH |
| status = usb_set_interface(ctrl); |
| #endif /* CONFIG_CARL9170FW_USB_MODESWITCH */ |
| break; |
| |
| case USB_REQ_SYNCH_FRAME: |
| break; |
| |
| default: |
| break; |
| |
| } |
| #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */ |
| |
| return status; |
| } |
| |
| static int usb_class_command(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| return -1; |
| } |
| |
| static int usb_vendor_command(const struct usb_ctrlrequest *ctrl __unused) |
| { |
| /* |
| * Note: Firmware upload/boot is not implemented. |
| * It's impossible to replace the current image |
| * in place. |
| */ |
| |
| return -1; |
| } |
| |
| #undef USB_CHECK_TYPE |
| |
| void usb_ep0setup(void) |
| { |
| struct usb_ctrlrequest ctrl; |
| int status = -1; |
| usb_ep0rx_data(&ctrl, sizeof(ctrl)); |
| |
| switch (ctrl.bRequestType & USB_TYPE_MASK) { |
| case USB_TYPE_STANDARD: |
| status = usb_standard_command(&ctrl); |
| break; |
| |
| case USB_TYPE_CLASS: |
| status = usb_class_command(&ctrl); |
| break; |
| |
| case USB_TYPE_VENDOR: |
| status = usb_vendor_command(&ctrl); |
| break; |
| |
| default: |
| break; |
| |
| } |
| |
| if (status < 0) |
| fw.usb.ep0_action |= CARL9170_EP0_STALL; |
| #ifdef CONFIG_CARL9170FW_USB_STANDARD_CMDS |
| if (status > 0) |
| fw.usb.ep0_action |= CARL9170_EP0_TRIGGER; |
| #endif /* CONFIG_CARL9170FW_USB_STANDARD_CMDS */ |
| } |
| |
| void usb_ep0rx(void) |
| { |
| if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len)) |
| return ; |
| |
| usb_ep0rx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len); |
| fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len; |
| } |
| |
| void usb_ep0tx(void) |
| { |
| if (BUG_ON(!fw.usb.ep0_txrx_buffer || !fw.usb.ep0_txrx_len)) |
| return ; |
| |
| usb_ep0tx_data(fw.usb.ep0_txrx_buffer, fw.usb.ep0_txrx_len); |
| fw.usb.ep0_txrx_pos = fw.usb.ep0_txrx_len; |
| } |