15853e133SVivek Gautam /* 25853e133SVivek Gautam * USB HOST XHCI Controller stack 35853e133SVivek Gautam * 45853e133SVivek Gautam * Based on xHCI host controller driver in linux-kernel 55853e133SVivek Gautam * by Sarah Sharp. 65853e133SVivek Gautam * 75853e133SVivek Gautam * Copyright (C) 2008 Intel Corp. 85853e133SVivek Gautam * Author: Sarah Sharp 95853e133SVivek Gautam * 105853e133SVivek Gautam * Copyright (C) 2013 Samsung Electronics Co.Ltd 115853e133SVivek Gautam * Authors: Vivek Gautam <gautam.vivek@samsung.com> 125853e133SVivek Gautam * Vikas Sajjan <vikas.sajjan@samsung.com> 135853e133SVivek Gautam * 145853e133SVivek Gautam * SPDX-License-Identifier: GPL-2.0+ 155853e133SVivek Gautam */ 165853e133SVivek Gautam 175853e133SVivek Gautam /** 185853e133SVivek Gautam * This file gives the xhci stack for usb3.0 looking into 195853e133SVivek Gautam * xhci specification Rev1.0 (5/21/10). 205853e133SVivek Gautam * The quirk devices support hasn't been given yet. 215853e133SVivek Gautam */ 225853e133SVivek Gautam 235853e133SVivek Gautam #include <common.h> 24a5762fe0SSimon Glass #include <dm.h> 255853e133SVivek Gautam #include <asm/byteorder.h> 265853e133SVivek Gautam #include <usb.h> 275853e133SVivek Gautam #include <malloc.h> 285853e133SVivek Gautam #include <watchdog.h> 295853e133SVivek Gautam #include <asm/cache.h> 305853e133SVivek Gautam #include <asm/unaligned.h> 315d97dff0SMasahiro Yamada #include <linux/errno.h> 325853e133SVivek Gautam #include "xhci.h" 335853e133SVivek Gautam 345853e133SVivek Gautam #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT 355853e133SVivek Gautam #define CONFIG_USB_MAX_CONTROLLER_COUNT 1 365853e133SVivek Gautam #endif 375853e133SVivek Gautam 385853e133SVivek Gautam static struct descriptor { 395853e133SVivek Gautam struct usb_hub_descriptor hub; 405853e133SVivek Gautam struct usb_device_descriptor device; 415853e133SVivek Gautam struct usb_config_descriptor config; 425853e133SVivek Gautam struct usb_interface_descriptor interface; 435853e133SVivek Gautam struct usb_endpoint_descriptor endpoint; 445853e133SVivek Gautam struct usb_ss_ep_comp_descriptor ep_companion; 455853e133SVivek Gautam } __attribute__ ((packed)) descriptor = { 465853e133SVivek Gautam { 475853e133SVivek Gautam 0xc, /* bDescLength */ 485853e133SVivek Gautam 0x2a, /* bDescriptorType: hub descriptor */ 495853e133SVivek Gautam 2, /* bNrPorts -- runtime modified */ 505853e133SVivek Gautam cpu_to_le16(0x8), /* wHubCharacteristics */ 515853e133SVivek Gautam 10, /* bPwrOn2PwrGood */ 525853e133SVivek Gautam 0, /* bHubCntrCurrent */ 535853e133SVivek Gautam {}, /* Device removable */ 545853e133SVivek Gautam {} /* at most 7 ports! XXX */ 555853e133SVivek Gautam }, 565853e133SVivek Gautam { 575853e133SVivek Gautam 0x12, /* bLength */ 585853e133SVivek Gautam 1, /* bDescriptorType: UDESC_DEVICE */ 595853e133SVivek Gautam cpu_to_le16(0x0300), /* bcdUSB: v3.0 */ 605853e133SVivek Gautam 9, /* bDeviceClass: UDCLASS_HUB */ 615853e133SVivek Gautam 0, /* bDeviceSubClass: UDSUBCLASS_HUB */ 625853e133SVivek Gautam 3, /* bDeviceProtocol: UDPROTO_SSHUBSTT */ 635853e133SVivek Gautam 9, /* bMaxPacketSize: 512 bytes 2^9 */ 645853e133SVivek Gautam 0x0000, /* idVendor */ 655853e133SVivek Gautam 0x0000, /* idProduct */ 665853e133SVivek Gautam cpu_to_le16(0x0100), /* bcdDevice */ 675853e133SVivek Gautam 1, /* iManufacturer */ 685853e133SVivek Gautam 2, /* iProduct */ 695853e133SVivek Gautam 0, /* iSerialNumber */ 705853e133SVivek Gautam 1 /* bNumConfigurations: 1 */ 715853e133SVivek Gautam }, 725853e133SVivek Gautam { 735853e133SVivek Gautam 0x9, 745853e133SVivek Gautam 2, /* bDescriptorType: UDESC_CONFIG */ 755853e133SVivek Gautam cpu_to_le16(0x1f), /* includes SS endpoint descriptor */ 765853e133SVivek Gautam 1, /* bNumInterface */ 775853e133SVivek Gautam 1, /* bConfigurationValue */ 785853e133SVivek Gautam 0, /* iConfiguration */ 795853e133SVivek Gautam 0x40, /* bmAttributes: UC_SELF_POWER */ 805853e133SVivek Gautam 0 /* bMaxPower */ 815853e133SVivek Gautam }, 825853e133SVivek Gautam { 835853e133SVivek Gautam 0x9, /* bLength */ 845853e133SVivek Gautam 4, /* bDescriptorType: UDESC_INTERFACE */ 855853e133SVivek Gautam 0, /* bInterfaceNumber */ 865853e133SVivek Gautam 0, /* bAlternateSetting */ 875853e133SVivek Gautam 1, /* bNumEndpoints */ 885853e133SVivek Gautam 9, /* bInterfaceClass: UICLASS_HUB */ 895853e133SVivek Gautam 0, /* bInterfaceSubClass: UISUBCLASS_HUB */ 905853e133SVivek Gautam 0, /* bInterfaceProtocol: UIPROTO_HSHUBSTT */ 915853e133SVivek Gautam 0 /* iInterface */ 925853e133SVivek Gautam }, 935853e133SVivek Gautam { 945853e133SVivek Gautam 0x7, /* bLength */ 955853e133SVivek Gautam 5, /* bDescriptorType: UDESC_ENDPOINT */ 965853e133SVivek Gautam 0x81, /* bEndpointAddress: IN endpoint 1 */ 975853e133SVivek Gautam 3, /* bmAttributes: UE_INTERRUPT */ 985853e133SVivek Gautam 8, /* wMaxPacketSize */ 995853e133SVivek Gautam 255 /* bInterval */ 1005853e133SVivek Gautam }, 1015853e133SVivek Gautam { 1025853e133SVivek Gautam 0x06, /* ss_bLength */ 1035853e133SVivek Gautam 0x30, /* ss_bDescriptorType: SS EP Companion */ 1045853e133SVivek Gautam 0x00, /* ss_bMaxBurst: allows 1 TX between ACKs */ 1055853e133SVivek Gautam /* ss_bmAttributes: 1 packet per service interval */ 1065853e133SVivek Gautam 0x00, 1075853e133SVivek Gautam /* ss_wBytesPerInterval: 15 bits for max 15 ports */ 1085853e133SVivek Gautam cpu_to_le16(0x02), 1095853e133SVivek Gautam }, 1105853e133SVivek Gautam }; 1115853e133SVivek Gautam 112a5762fe0SSimon Glass #ifndef CONFIG_DM_USB 1135853e133SVivek Gautam static struct xhci_ctrl xhcic[CONFIG_USB_MAX_CONTROLLER_COUNT]; 114a5762fe0SSimon Glass #endif 1155853e133SVivek Gautam 1167c1deec0SSimon Glass struct xhci_ctrl *xhci_get_ctrl(struct usb_device *udev) 1177c1deec0SSimon Glass { 118a5762fe0SSimon Glass #ifdef CONFIG_DM_USB 119a5762fe0SSimon Glass struct udevice *dev; 120a5762fe0SSimon Glass 121a5762fe0SSimon Glass /* Find the USB controller */ 122a5762fe0SSimon Glass for (dev = udev->dev; 123a5762fe0SSimon Glass device_get_uclass_id(dev) != UCLASS_USB; 124a5762fe0SSimon Glass dev = dev->parent) 125a5762fe0SSimon Glass ; 126a5762fe0SSimon Glass return dev_get_priv(dev); 127a5762fe0SSimon Glass #else 1287c1deec0SSimon Glass return udev->controller; 129a5762fe0SSimon Glass #endif 1307c1deec0SSimon Glass } 1317c1deec0SSimon Glass 1325853e133SVivek Gautam /** 1335853e133SVivek Gautam * Waits for as per specified amount of time 1345853e133SVivek Gautam * for the "result" to match with "done" 1355853e133SVivek Gautam * 1365853e133SVivek Gautam * @param ptr pointer to the register to be read 1375853e133SVivek Gautam * @param mask mask for the value read 1385853e133SVivek Gautam * @param done value to be campared with result 1395853e133SVivek Gautam * @param usec time to wait till 1405853e133SVivek Gautam * @return 0 if handshake is success else < 0 on failure 1415853e133SVivek Gautam */ 1425853e133SVivek Gautam static int handshake(uint32_t volatile *ptr, uint32_t mask, 1435853e133SVivek Gautam uint32_t done, int usec) 1445853e133SVivek Gautam { 1455853e133SVivek Gautam uint32_t result; 1465853e133SVivek Gautam 1475853e133SVivek Gautam do { 1485853e133SVivek Gautam result = xhci_readl(ptr); 1495853e133SVivek Gautam if (result == ~(uint32_t)0) 1505853e133SVivek Gautam return -ENODEV; 1515853e133SVivek Gautam result &= mask; 1525853e133SVivek Gautam if (result == done) 1535853e133SVivek Gautam return 0; 1545853e133SVivek Gautam usec--; 1555853e133SVivek Gautam udelay(1); 1565853e133SVivek Gautam } while (usec > 0); 1575853e133SVivek Gautam 1585853e133SVivek Gautam return -ETIMEDOUT; 1595853e133SVivek Gautam } 1605853e133SVivek Gautam 1615853e133SVivek Gautam /** 1625853e133SVivek Gautam * Set the run bit and wait for the host to be running. 1635853e133SVivek Gautam * 1645853e133SVivek Gautam * @param hcor pointer to host controller operation registers 1655853e133SVivek Gautam * @return status of the Handshake 1665853e133SVivek Gautam */ 1675853e133SVivek Gautam static int xhci_start(struct xhci_hcor *hcor) 1685853e133SVivek Gautam { 1695853e133SVivek Gautam u32 temp; 1705853e133SVivek Gautam int ret; 1715853e133SVivek Gautam 1725853e133SVivek Gautam puts("Starting the controller\n"); 1735853e133SVivek Gautam temp = xhci_readl(&hcor->or_usbcmd); 1745853e133SVivek Gautam temp |= (CMD_RUN); 1755853e133SVivek Gautam xhci_writel(&hcor->or_usbcmd, temp); 1765853e133SVivek Gautam 1775853e133SVivek Gautam /* 1785853e133SVivek Gautam * Wait for the HCHalted Status bit to be 0 to indicate the host is 1795853e133SVivek Gautam * running. 1805853e133SVivek Gautam */ 1815853e133SVivek Gautam ret = handshake(&hcor->or_usbsts, STS_HALT, 0, XHCI_MAX_HALT_USEC); 1825853e133SVivek Gautam if (ret) 1835853e133SVivek Gautam debug("Host took too long to start, " 1845853e133SVivek Gautam "waited %u microseconds.\n", 1855853e133SVivek Gautam XHCI_MAX_HALT_USEC); 1865853e133SVivek Gautam return ret; 1875853e133SVivek Gautam } 1885853e133SVivek Gautam 1895853e133SVivek Gautam /** 1905853e133SVivek Gautam * Resets the XHCI Controller 1915853e133SVivek Gautam * 1925853e133SVivek Gautam * @param hcor pointer to host controller operation registers 1935853e133SVivek Gautam * @return -EBUSY if XHCI Controller is not halted else status of handshake 1945853e133SVivek Gautam */ 195121a4d13SMasahiro Yamada static int xhci_reset(struct xhci_hcor *hcor) 1965853e133SVivek Gautam { 1975853e133SVivek Gautam u32 cmd; 1985853e133SVivek Gautam u32 state; 1995853e133SVivek Gautam int ret; 2005853e133SVivek Gautam 2015853e133SVivek Gautam /* Halting the Host first */ 202a5ccda47SSergey Temerkhanov debug("// Halt the HC: %p\n", hcor); 2035853e133SVivek Gautam state = xhci_readl(&hcor->or_usbsts) & STS_HALT; 2045853e133SVivek Gautam if (!state) { 2055853e133SVivek Gautam cmd = xhci_readl(&hcor->or_usbcmd); 2065853e133SVivek Gautam cmd &= ~CMD_RUN; 2075853e133SVivek Gautam xhci_writel(&hcor->or_usbcmd, cmd); 2085853e133SVivek Gautam } 2095853e133SVivek Gautam 2105853e133SVivek Gautam ret = handshake(&hcor->or_usbsts, 2115853e133SVivek Gautam STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC); 2125853e133SVivek Gautam if (ret) { 2135853e133SVivek Gautam printf("Host not halted after %u microseconds.\n", 2145853e133SVivek Gautam XHCI_MAX_HALT_USEC); 2155853e133SVivek Gautam return -EBUSY; 2165853e133SVivek Gautam } 2175853e133SVivek Gautam 2185853e133SVivek Gautam debug("// Reset the HC\n"); 2195853e133SVivek Gautam cmd = xhci_readl(&hcor->or_usbcmd); 2205853e133SVivek Gautam cmd |= CMD_RESET; 2215853e133SVivek Gautam xhci_writel(&hcor->or_usbcmd, cmd); 2225853e133SVivek Gautam 2235853e133SVivek Gautam ret = handshake(&hcor->or_usbcmd, CMD_RESET, 0, XHCI_MAX_RESET_USEC); 2245853e133SVivek Gautam if (ret) 2255853e133SVivek Gautam return ret; 2265853e133SVivek Gautam 2275853e133SVivek Gautam /* 2285853e133SVivek Gautam * xHCI cannot write to any doorbells or operational registers other 2295853e133SVivek Gautam * than status until the "Controller Not Ready" flag is cleared. 2305853e133SVivek Gautam */ 2315853e133SVivek Gautam return handshake(&hcor->or_usbsts, STS_CNR, 0, XHCI_MAX_RESET_USEC); 2325853e133SVivek Gautam } 2335853e133SVivek Gautam 2345853e133SVivek Gautam /** 2355853e133SVivek Gautam * Used for passing endpoint bitmasks between the core and HCDs. 2365853e133SVivek Gautam * Find the index for an endpoint given its descriptor. 2375853e133SVivek Gautam * Use the return value to right shift 1 for the bitmask. 2385853e133SVivek Gautam * 2395853e133SVivek Gautam * Index = (epnum * 2) + direction - 1, 2405853e133SVivek Gautam * where direction = 0 for OUT, 1 for IN. 2415853e133SVivek Gautam * For control endpoints, the IN index is used (OUT index is unused), so 2425853e133SVivek Gautam * index = (epnum * 2) + direction - 1 = (epnum * 2) + 1 - 1 = (epnum * 2) 2435853e133SVivek Gautam * 2445853e133SVivek Gautam * @param desc USB enpdoint Descriptor 2455853e133SVivek Gautam * @return index of the Endpoint 2465853e133SVivek Gautam */ 2475853e133SVivek Gautam static unsigned int xhci_get_ep_index(struct usb_endpoint_descriptor *desc) 2485853e133SVivek Gautam { 2495853e133SVivek Gautam unsigned int index; 2505853e133SVivek Gautam 2515853e133SVivek Gautam if (usb_endpoint_xfer_control(desc)) 2525853e133SVivek Gautam index = (unsigned int)(usb_endpoint_num(desc) * 2); 2535853e133SVivek Gautam else 2545853e133SVivek Gautam index = (unsigned int)((usb_endpoint_num(desc) * 2) - 2555853e133SVivek Gautam (usb_endpoint_dir_in(desc) ? 0 : 1)); 2565853e133SVivek Gautam 2575853e133SVivek Gautam return index; 2585853e133SVivek Gautam } 2595853e133SVivek Gautam 2605853e133SVivek Gautam /** 2615853e133SVivek Gautam * Issue a configure endpoint command or evaluate context command 2625853e133SVivek Gautam * and wait for it to finish. 2635853e133SVivek Gautam * 2645853e133SVivek Gautam * @param udev pointer to the Device Data Structure 2655853e133SVivek Gautam * @param ctx_change flag to indicate the Context has changed or NOT 2665853e133SVivek Gautam * @return 0 on success, -1 on failure 2675853e133SVivek Gautam */ 2685853e133SVivek Gautam static int xhci_configure_endpoints(struct usb_device *udev, bool ctx_change) 2695853e133SVivek Gautam { 2705853e133SVivek Gautam struct xhci_container_ctx *in_ctx; 2715853e133SVivek Gautam struct xhci_virt_device *virt_dev; 2727c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 2735853e133SVivek Gautam union xhci_trb *event; 2745853e133SVivek Gautam 2755853e133SVivek Gautam virt_dev = ctrl->devs[udev->slot_id]; 2765853e133SVivek Gautam in_ctx = virt_dev->in_ctx; 2775853e133SVivek Gautam 278421a5a0cSSergey Temerkhanov xhci_flush_cache((uintptr_t)in_ctx->bytes, in_ctx->size); 2795853e133SVivek Gautam xhci_queue_command(ctrl, in_ctx->bytes, udev->slot_id, 0, 2805853e133SVivek Gautam ctx_change ? TRB_EVAL_CONTEXT : TRB_CONFIG_EP); 2815853e133SVivek Gautam event = xhci_wait_for_event(ctrl, TRB_COMPLETION); 2825853e133SVivek Gautam BUG_ON(TRB_TO_SLOT_ID(le32_to_cpu(event->event_cmd.flags)) 2835853e133SVivek Gautam != udev->slot_id); 2845853e133SVivek Gautam 2855853e133SVivek Gautam switch (GET_COMP_CODE(le32_to_cpu(event->event_cmd.status))) { 2865853e133SVivek Gautam case COMP_SUCCESS: 2875853e133SVivek Gautam debug("Successful %s command\n", 2885853e133SVivek Gautam ctx_change ? "Evaluate Context" : "Configure Endpoint"); 2895853e133SVivek Gautam break; 2905853e133SVivek Gautam default: 2915853e133SVivek Gautam printf("ERROR: %s command returned completion code %d.\n", 2925853e133SVivek Gautam ctx_change ? "Evaluate Context" : "Configure Endpoint", 2935853e133SVivek Gautam GET_COMP_CODE(le32_to_cpu(event->event_cmd.status))); 2945853e133SVivek Gautam return -EINVAL; 2955853e133SVivek Gautam } 2965853e133SVivek Gautam 2975853e133SVivek Gautam xhci_acknowledge_event(ctrl); 2985853e133SVivek Gautam 2995853e133SVivek Gautam return 0; 3005853e133SVivek Gautam } 3015853e133SVivek Gautam 3025853e133SVivek Gautam /** 3035853e133SVivek Gautam * Configure the endpoint, programming the device contexts. 3045853e133SVivek Gautam * 3055853e133SVivek Gautam * @param udev pointer to the USB device structure 3065853e133SVivek Gautam * @return returns the status of the xhci_configure_endpoints 3075853e133SVivek Gautam */ 3085853e133SVivek Gautam static int xhci_set_configuration(struct usb_device *udev) 3095853e133SVivek Gautam { 3105853e133SVivek Gautam struct xhci_container_ctx *in_ctx; 3115853e133SVivek Gautam struct xhci_container_ctx *out_ctx; 3125853e133SVivek Gautam struct xhci_input_control_ctx *ctrl_ctx; 3135853e133SVivek Gautam struct xhci_slot_ctx *slot_ctx; 3145853e133SVivek Gautam struct xhci_ep_ctx *ep_ctx[MAX_EP_CTX_NUM]; 3155853e133SVivek Gautam int cur_ep; 3165853e133SVivek Gautam int max_ep_flag = 0; 3175853e133SVivek Gautam int ep_index; 3185853e133SVivek Gautam unsigned int dir; 3195853e133SVivek Gautam unsigned int ep_type; 3207c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 3215853e133SVivek Gautam int num_of_ep; 3225853e133SVivek Gautam int ep_flag = 0; 3235853e133SVivek Gautam u64 trb_64 = 0; 3245853e133SVivek Gautam int slot_id = udev->slot_id; 3255853e133SVivek Gautam struct xhci_virt_device *virt_dev = ctrl->devs[slot_id]; 3265853e133SVivek Gautam struct usb_interface *ifdesc; 3275853e133SVivek Gautam 3285853e133SVivek Gautam out_ctx = virt_dev->out_ctx; 3295853e133SVivek Gautam in_ctx = virt_dev->in_ctx; 3305853e133SVivek Gautam 3315853e133SVivek Gautam num_of_ep = udev->config.if_desc[0].no_of_ep; 3325853e133SVivek Gautam ifdesc = &udev->config.if_desc[0]; 3335853e133SVivek Gautam 3345853e133SVivek Gautam ctrl_ctx = xhci_get_input_control_ctx(in_ctx); 335aab0db08SBin Meng /* Initialize the input context control */ 336aab0db08SBin Meng ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG); 3375853e133SVivek Gautam ctrl_ctx->drop_flags = 0; 3385853e133SVivek Gautam 3395853e133SVivek Gautam /* EP_FLAG gives values 1 & 4 for EP1OUT and EP2IN */ 3405853e133SVivek Gautam for (cur_ep = 0; cur_ep < num_of_ep; cur_ep++) { 3415853e133SVivek Gautam ep_flag = xhci_get_ep_index(&ifdesc->ep_desc[cur_ep]); 3425853e133SVivek Gautam ctrl_ctx->add_flags |= cpu_to_le32(1 << (ep_flag + 1)); 3435853e133SVivek Gautam if (max_ep_flag < ep_flag) 3445853e133SVivek Gautam max_ep_flag = ep_flag; 3455853e133SVivek Gautam } 3465853e133SVivek Gautam 347421a5a0cSSergey Temerkhanov xhci_inval_cache((uintptr_t)out_ctx->bytes, out_ctx->size); 3485853e133SVivek Gautam 3495853e133SVivek Gautam /* slot context */ 3505853e133SVivek Gautam xhci_slot_copy(ctrl, in_ctx, out_ctx); 3515853e133SVivek Gautam slot_ctx = xhci_get_slot_ctx(ctrl, in_ctx); 3525853e133SVivek Gautam slot_ctx->dev_info &= ~(LAST_CTX_MASK); 3535853e133SVivek Gautam slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(max_ep_flag + 1) | 0); 3545853e133SVivek Gautam 3555853e133SVivek Gautam xhci_endpoint_copy(ctrl, in_ctx, out_ctx, 0); 3565853e133SVivek Gautam 3575853e133SVivek Gautam /* filling up ep contexts */ 3585853e133SVivek Gautam for (cur_ep = 0; cur_ep < num_of_ep; cur_ep++) { 3595853e133SVivek Gautam struct usb_endpoint_descriptor *endpt_desc = NULL; 3605853e133SVivek Gautam 3615853e133SVivek Gautam endpt_desc = &ifdesc->ep_desc[cur_ep]; 3625853e133SVivek Gautam trb_64 = 0; 3635853e133SVivek Gautam 3645853e133SVivek Gautam ep_index = xhci_get_ep_index(endpt_desc); 3655853e133SVivek Gautam ep_ctx[ep_index] = xhci_get_ep_ctx(ctrl, in_ctx, ep_index); 3665853e133SVivek Gautam 3675853e133SVivek Gautam /* Allocate the ep rings */ 3685853e133SVivek Gautam virt_dev->eps[ep_index].ring = xhci_ring_alloc(1, true); 3695853e133SVivek Gautam if (!virt_dev->eps[ep_index].ring) 3705853e133SVivek Gautam return -ENOMEM; 3715853e133SVivek Gautam 3725853e133SVivek Gautam /*NOTE: ep_desc[0] actually represents EP1 and so on */ 3735853e133SVivek Gautam dir = (((endpt_desc->bEndpointAddress) & (0x80)) >> 7); 3745853e133SVivek Gautam ep_type = (((endpt_desc->bmAttributes) & (0x3)) | (dir << 2)); 3755853e133SVivek Gautam ep_ctx[ep_index]->ep_info2 = 3765853e133SVivek Gautam cpu_to_le32(ep_type << EP_TYPE_SHIFT); 3775853e133SVivek Gautam ep_ctx[ep_index]->ep_info2 |= 3785853e133SVivek Gautam cpu_to_le32(MAX_PACKET 3795853e133SVivek Gautam (get_unaligned(&endpt_desc->wMaxPacketSize))); 3805853e133SVivek Gautam 3815853e133SVivek Gautam ep_ctx[ep_index]->ep_info2 |= 3825853e133SVivek Gautam cpu_to_le32(((0 & MAX_BURST_MASK) << MAX_BURST_SHIFT) | 3835853e133SVivek Gautam ((3 & ERROR_COUNT_MASK) << ERROR_COUNT_SHIFT)); 3845853e133SVivek Gautam 3855853e133SVivek Gautam trb_64 = (uintptr_t) 3865853e133SVivek Gautam virt_dev->eps[ep_index].ring->enqueue; 3875853e133SVivek Gautam ep_ctx[ep_index]->deq = cpu_to_le64(trb_64 | 3885853e133SVivek Gautam virt_dev->eps[ep_index].ring->cycle_state); 3895853e133SVivek Gautam } 3905853e133SVivek Gautam 3915853e133SVivek Gautam return xhci_configure_endpoints(udev, false); 3925853e133SVivek Gautam } 3935853e133SVivek Gautam 3945853e133SVivek Gautam /** 3955853e133SVivek Gautam * Issue an Address Device command (which will issue a SetAddress request to 3965853e133SVivek Gautam * the device). 3975853e133SVivek Gautam * 3985853e133SVivek Gautam * @param udev pointer to the Device Data Structure 3995853e133SVivek Gautam * @return 0 if successful else error code on failure 4005853e133SVivek Gautam */ 4015dd75e3bSSimon Glass static int xhci_address_device(struct usb_device *udev, int root_portnr) 4025853e133SVivek Gautam { 4035853e133SVivek Gautam int ret = 0; 4047c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 4055853e133SVivek Gautam struct xhci_slot_ctx *slot_ctx; 4065853e133SVivek Gautam struct xhci_input_control_ctx *ctrl_ctx; 4075853e133SVivek Gautam struct xhci_virt_device *virt_dev; 4085853e133SVivek Gautam int slot_id = udev->slot_id; 4095853e133SVivek Gautam union xhci_trb *event; 4105853e133SVivek Gautam 4115853e133SVivek Gautam virt_dev = ctrl->devs[slot_id]; 4125853e133SVivek Gautam 4135853e133SVivek Gautam /* 4145853e133SVivek Gautam * This is the first Set Address since device plug-in 4155853e133SVivek Gautam * so setting up the slot context. 4165853e133SVivek Gautam */ 4175dd75e3bSSimon Glass debug("Setting up addressable devices %p\n", ctrl->dcbaa); 4185dd75e3bSSimon Glass xhci_setup_addressable_virt_dev(ctrl, udev->slot_id, udev->speed, 4195dd75e3bSSimon Glass root_portnr); 4205853e133SVivek Gautam 4215853e133SVivek Gautam ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx); 4225853e133SVivek Gautam ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG); 4235853e133SVivek Gautam ctrl_ctx->drop_flags = 0; 4245853e133SVivek Gautam 4255853e133SVivek Gautam xhci_queue_command(ctrl, (void *)ctrl_ctx, slot_id, 0, TRB_ADDR_DEV); 4265853e133SVivek Gautam event = xhci_wait_for_event(ctrl, TRB_COMPLETION); 4275853e133SVivek Gautam BUG_ON(TRB_TO_SLOT_ID(le32_to_cpu(event->event_cmd.flags)) != slot_id); 4285853e133SVivek Gautam 4295853e133SVivek Gautam switch (GET_COMP_CODE(le32_to_cpu(event->event_cmd.status))) { 4305853e133SVivek Gautam case COMP_CTX_STATE: 4315853e133SVivek Gautam case COMP_EBADSLT: 4325853e133SVivek Gautam printf("Setup ERROR: address device command for slot %d.\n", 4335853e133SVivek Gautam slot_id); 4345853e133SVivek Gautam ret = -EINVAL; 4355853e133SVivek Gautam break; 4365853e133SVivek Gautam case COMP_TX_ERR: 4375853e133SVivek Gautam puts("Device not responding to set address.\n"); 4385853e133SVivek Gautam ret = -EPROTO; 4395853e133SVivek Gautam break; 4405853e133SVivek Gautam case COMP_DEV_ERR: 4415853e133SVivek Gautam puts("ERROR: Incompatible device" 4425853e133SVivek Gautam "for address device command.\n"); 4435853e133SVivek Gautam ret = -ENODEV; 4445853e133SVivek Gautam break; 4455853e133SVivek Gautam case COMP_SUCCESS: 4465853e133SVivek Gautam debug("Successful Address Device command\n"); 4475853e133SVivek Gautam udev->status = 0; 4485853e133SVivek Gautam break; 4495853e133SVivek Gautam default: 4505853e133SVivek Gautam printf("ERROR: unexpected command completion code 0x%x.\n", 4515853e133SVivek Gautam GET_COMP_CODE(le32_to_cpu(event->event_cmd.status))); 4525853e133SVivek Gautam ret = -EINVAL; 4535853e133SVivek Gautam break; 4545853e133SVivek Gautam } 4555853e133SVivek Gautam 4565853e133SVivek Gautam xhci_acknowledge_event(ctrl); 4575853e133SVivek Gautam 4585853e133SVivek Gautam if (ret < 0) 4595853e133SVivek Gautam /* 4605853e133SVivek Gautam * TODO: Unsuccessful Address Device command shall leave the 4615853e133SVivek Gautam * slot in default state. So, issue Disable Slot command now. 4625853e133SVivek Gautam */ 4635853e133SVivek Gautam return ret; 4645853e133SVivek Gautam 465421a5a0cSSergey Temerkhanov xhci_inval_cache((uintptr_t)virt_dev->out_ctx->bytes, 4665853e133SVivek Gautam virt_dev->out_ctx->size); 4675853e133SVivek Gautam slot_ctx = xhci_get_slot_ctx(ctrl, virt_dev->out_ctx); 4685853e133SVivek Gautam 4695853e133SVivek Gautam debug("xHC internal address is: %d\n", 4705853e133SVivek Gautam le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK); 4715853e133SVivek Gautam 4725853e133SVivek Gautam return 0; 4735853e133SVivek Gautam } 4745853e133SVivek Gautam 4755853e133SVivek Gautam /** 4765853e133SVivek Gautam * Issue Enable slot command to the controller to allocate 4775853e133SVivek Gautam * device slot and assign the slot id. It fails if the xHC 4785853e133SVivek Gautam * ran out of device slots, the Enable Slot command timed out, 4795853e133SVivek Gautam * or allocating memory failed. 4805853e133SVivek Gautam * 4815853e133SVivek Gautam * @param udev pointer to the Device Data Structure 4825853e133SVivek Gautam * @return Returns 0 on succes else return error code on failure 4835853e133SVivek Gautam */ 484121a4d13SMasahiro Yamada static int _xhci_alloc_device(struct usb_device *udev) 4855853e133SVivek Gautam { 4867c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 4875853e133SVivek Gautam union xhci_trb *event; 4885853e133SVivek Gautam int ret; 4895853e133SVivek Gautam 4905853e133SVivek Gautam /* 4915853e133SVivek Gautam * Root hub will be first device to be initailized. 4925853e133SVivek Gautam * If this device is root-hub, don't do any xHC related 4935853e133SVivek Gautam * stuff. 4945853e133SVivek Gautam */ 4955853e133SVivek Gautam if (ctrl->rootdev == 0) { 4965853e133SVivek Gautam udev->speed = USB_SPEED_SUPER; 4975853e133SVivek Gautam return 0; 4985853e133SVivek Gautam } 4995853e133SVivek Gautam 5005853e133SVivek Gautam xhci_queue_command(ctrl, NULL, 0, 0, TRB_ENABLE_SLOT); 5015853e133SVivek Gautam event = xhci_wait_for_event(ctrl, TRB_COMPLETION); 5025853e133SVivek Gautam BUG_ON(GET_COMP_CODE(le32_to_cpu(event->event_cmd.status)) 5035853e133SVivek Gautam != COMP_SUCCESS); 5045853e133SVivek Gautam 5055853e133SVivek Gautam udev->slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->event_cmd.flags)); 5065853e133SVivek Gautam 5075853e133SVivek Gautam xhci_acknowledge_event(ctrl); 5085853e133SVivek Gautam 5097e0c5ee8SSimon Glass ret = xhci_alloc_virt_device(ctrl, udev->slot_id); 5105853e133SVivek Gautam if (ret < 0) { 5115853e133SVivek Gautam /* 5125853e133SVivek Gautam * TODO: Unsuccessful Address Device command shall leave 5135853e133SVivek Gautam * the slot in default. So, issue Disable Slot command now. 5145853e133SVivek Gautam */ 5155853e133SVivek Gautam puts("Could not allocate xHCI USB device data structures\n"); 5165853e133SVivek Gautam return ret; 5175853e133SVivek Gautam } 5185853e133SVivek Gautam 5195853e133SVivek Gautam return 0; 5205853e133SVivek Gautam } 5215853e133SVivek Gautam 522a5762fe0SSimon Glass #ifndef CONFIG_DM_USB 523a5762fe0SSimon Glass int usb_alloc_device(struct usb_device *udev) 524a5762fe0SSimon Glass { 525a5762fe0SSimon Glass return _xhci_alloc_device(udev); 526a5762fe0SSimon Glass } 527a5762fe0SSimon Glass #endif 528a5762fe0SSimon Glass 5295853e133SVivek Gautam /* 5305853e133SVivek Gautam * Full speed devices may have a max packet size greater than 8 bytes, but the 5315853e133SVivek Gautam * USB core doesn't know that until it reads the first 8 bytes of the 5325853e133SVivek Gautam * descriptor. If the usb_device's max packet size changes after that point, 5335853e133SVivek Gautam * we need to issue an evaluate context command and wait on it. 5345853e133SVivek Gautam * 5355853e133SVivek Gautam * @param udev pointer to the Device Data Structure 5365853e133SVivek Gautam * @return returns the status of the xhci_configure_endpoints 5375853e133SVivek Gautam */ 5385853e133SVivek Gautam int xhci_check_maxpacket(struct usb_device *udev) 5395853e133SVivek Gautam { 5407c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 5415853e133SVivek Gautam unsigned int slot_id = udev->slot_id; 5425853e133SVivek Gautam int ep_index = 0; /* control endpoint */ 5435853e133SVivek Gautam struct xhci_container_ctx *in_ctx; 5445853e133SVivek Gautam struct xhci_container_ctx *out_ctx; 5455853e133SVivek Gautam struct xhci_input_control_ctx *ctrl_ctx; 5465853e133SVivek Gautam struct xhci_ep_ctx *ep_ctx; 5475853e133SVivek Gautam int max_packet_size; 5485853e133SVivek Gautam int hw_max_packet_size; 5495853e133SVivek Gautam int ret = 0; 5505853e133SVivek Gautam struct usb_interface *ifdesc; 5515853e133SVivek Gautam 5525853e133SVivek Gautam ifdesc = &udev->config.if_desc[0]; 5535853e133SVivek Gautam 5545853e133SVivek Gautam out_ctx = ctrl->devs[slot_id]->out_ctx; 555421a5a0cSSergey Temerkhanov xhci_inval_cache((uintptr_t)out_ctx->bytes, out_ctx->size); 5565853e133SVivek Gautam 5575853e133SVivek Gautam ep_ctx = xhci_get_ep_ctx(ctrl, out_ctx, ep_index); 5585853e133SVivek Gautam hw_max_packet_size = MAX_PACKET_DECODED(le32_to_cpu(ep_ctx->ep_info2)); 5595853e133SVivek Gautam max_packet_size = usb_endpoint_maxp(&ifdesc->ep_desc[0]); 5605853e133SVivek Gautam if (hw_max_packet_size != max_packet_size) { 5615853e133SVivek Gautam debug("Max Packet Size for ep 0 changed.\n"); 5625853e133SVivek Gautam debug("Max packet size in usb_device = %d\n", max_packet_size); 5635853e133SVivek Gautam debug("Max packet size in xHCI HW = %d\n", hw_max_packet_size); 5645853e133SVivek Gautam debug("Issuing evaluate context command.\n"); 5655853e133SVivek Gautam 5665853e133SVivek Gautam /* Set up the modified control endpoint 0 */ 5675853e133SVivek Gautam xhci_endpoint_copy(ctrl, ctrl->devs[slot_id]->in_ctx, 5685853e133SVivek Gautam ctrl->devs[slot_id]->out_ctx, ep_index); 5695853e133SVivek Gautam in_ctx = ctrl->devs[slot_id]->in_ctx; 5705853e133SVivek Gautam ep_ctx = xhci_get_ep_ctx(ctrl, in_ctx, ep_index); 5715853e133SVivek Gautam ep_ctx->ep_info2 &= cpu_to_le32(~MAX_PACKET_MASK); 5725853e133SVivek Gautam ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet_size)); 5735853e133SVivek Gautam 5745853e133SVivek Gautam /* 5755853e133SVivek Gautam * Set up the input context flags for the command 5765853e133SVivek Gautam * FIXME: This won't work if a non-default control endpoint 5775853e133SVivek Gautam * changes max packet sizes. 5785853e133SVivek Gautam */ 5795853e133SVivek Gautam ctrl_ctx = xhci_get_input_control_ctx(in_ctx); 5805853e133SVivek Gautam ctrl_ctx->add_flags = cpu_to_le32(EP0_FLAG); 5815853e133SVivek Gautam ctrl_ctx->drop_flags = 0; 5825853e133SVivek Gautam 5835853e133SVivek Gautam ret = xhci_configure_endpoints(udev, true); 5845853e133SVivek Gautam } 5855853e133SVivek Gautam return ret; 5865853e133SVivek Gautam } 5875853e133SVivek Gautam 5885853e133SVivek Gautam /** 5895853e133SVivek Gautam * Clears the Change bits of the Port Status Register 5905853e133SVivek Gautam * 5915853e133SVivek Gautam * @param wValue request value 5925853e133SVivek Gautam * @param wIndex request index 5935853e133SVivek Gautam * @param addr address of posrt status register 5945853e133SVivek Gautam * @param port_status state of port status register 5955853e133SVivek Gautam * @return none 5965853e133SVivek Gautam */ 5975853e133SVivek Gautam static void xhci_clear_port_change_bit(u16 wValue, 5985853e133SVivek Gautam u16 wIndex, volatile uint32_t *addr, u32 port_status) 5995853e133SVivek Gautam { 6005853e133SVivek Gautam char *port_change_bit; 6015853e133SVivek Gautam u32 status; 6025853e133SVivek Gautam 6035853e133SVivek Gautam switch (wValue) { 6045853e133SVivek Gautam case USB_PORT_FEAT_C_RESET: 6055853e133SVivek Gautam status = PORT_RC; 6065853e133SVivek Gautam port_change_bit = "reset"; 6075853e133SVivek Gautam break; 6085853e133SVivek Gautam case USB_PORT_FEAT_C_CONNECTION: 6095853e133SVivek Gautam status = PORT_CSC; 6105853e133SVivek Gautam port_change_bit = "connect"; 6115853e133SVivek Gautam break; 6125853e133SVivek Gautam case USB_PORT_FEAT_C_OVER_CURRENT: 6135853e133SVivek Gautam status = PORT_OCC; 6145853e133SVivek Gautam port_change_bit = "over-current"; 6155853e133SVivek Gautam break; 6165853e133SVivek Gautam case USB_PORT_FEAT_C_ENABLE: 6175853e133SVivek Gautam status = PORT_PEC; 6185853e133SVivek Gautam port_change_bit = "enable/disable"; 6195853e133SVivek Gautam break; 6205853e133SVivek Gautam case USB_PORT_FEAT_C_SUSPEND: 6215853e133SVivek Gautam status = PORT_PLC; 6225853e133SVivek Gautam port_change_bit = "suspend/resume"; 6235853e133SVivek Gautam break; 6245853e133SVivek Gautam default: 6255853e133SVivek Gautam /* Should never happen */ 6265853e133SVivek Gautam return; 6275853e133SVivek Gautam } 6285853e133SVivek Gautam 6295853e133SVivek Gautam /* Change bits are all write 1 to clear */ 6305853e133SVivek Gautam xhci_writel(addr, port_status | status); 6315853e133SVivek Gautam 6325853e133SVivek Gautam port_status = xhci_readl(addr); 6335853e133SVivek Gautam debug("clear port %s change, actual port %d status = 0x%x\n", 6345853e133SVivek Gautam port_change_bit, wIndex, port_status); 6355853e133SVivek Gautam } 6365853e133SVivek Gautam 6375853e133SVivek Gautam /** 6385853e133SVivek Gautam * Save Read Only (RO) bits and save read/write bits where 6395853e133SVivek Gautam * writing a 0 clears the bit and writing a 1 sets the bit (RWS). 6405853e133SVivek Gautam * For all other types (RW1S, RW1CS, RW, and RZ), writing a '0' has no effect. 6415853e133SVivek Gautam * 6425853e133SVivek Gautam * @param state state of the Port Status and Control Regsiter 6435853e133SVivek Gautam * @return a value that would result in the port being in the 6445853e133SVivek Gautam * same state, if the value was written to the port 6455853e133SVivek Gautam * status control register. 6465853e133SVivek Gautam */ 6475853e133SVivek Gautam static u32 xhci_port_state_to_neutral(u32 state) 6485853e133SVivek Gautam { 6495853e133SVivek Gautam /* Save read-only status and port state */ 6505853e133SVivek Gautam return (state & XHCI_PORT_RO) | (state & XHCI_PORT_RWS); 6515853e133SVivek Gautam } 6525853e133SVivek Gautam 6535853e133SVivek Gautam /** 6545853e133SVivek Gautam * Submits the Requests to the XHCI Host Controller 6555853e133SVivek Gautam * 6565853e133SVivek Gautam * @param udev pointer to the USB device structure 6575853e133SVivek Gautam * @param pipe contains the DIR_IN or OUT , devnum 6585853e133SVivek Gautam * @param buffer buffer to be read/written based on the request 6595853e133SVivek Gautam * @return returns 0 if successful else -1 on failure 6605853e133SVivek Gautam */ 6615853e133SVivek Gautam static int xhci_submit_root(struct usb_device *udev, unsigned long pipe, 6625853e133SVivek Gautam void *buffer, struct devrequest *req) 6635853e133SVivek Gautam { 6645853e133SVivek Gautam uint8_t tmpbuf[4]; 6655853e133SVivek Gautam u16 typeReq; 6665853e133SVivek Gautam void *srcptr = NULL; 6675853e133SVivek Gautam int len, srclen; 6685853e133SVivek Gautam uint32_t reg; 6695853e133SVivek Gautam volatile uint32_t *status_reg; 6707c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 6715853e133SVivek Gautam struct xhci_hcor *hcor = ctrl->hcor; 6725853e133SVivek Gautam 67325d1936aSJeroen Hofstee if ((req->requesttype & USB_RT_PORT) && 67425d1936aSJeroen Hofstee le16_to_cpu(req->index) > CONFIG_SYS_USB_XHCI_MAX_ROOT_PORTS) { 6755853e133SVivek Gautam printf("The request port(%d) is not configured\n", 6765853e133SVivek Gautam le16_to_cpu(req->index) - 1); 6775853e133SVivek Gautam return -EINVAL; 6785853e133SVivek Gautam } 6795853e133SVivek Gautam 6805853e133SVivek Gautam status_reg = (volatile uint32_t *) 6815853e133SVivek Gautam (&hcor->portregs[le16_to_cpu(req->index) - 1].or_portsc); 6825853e133SVivek Gautam srclen = 0; 6835853e133SVivek Gautam 6845853e133SVivek Gautam typeReq = req->request | req->requesttype << 8; 6855853e133SVivek Gautam 6865853e133SVivek Gautam switch (typeReq) { 6875853e133SVivek Gautam case DeviceRequest | USB_REQ_GET_DESCRIPTOR: 6885853e133SVivek Gautam switch (le16_to_cpu(req->value) >> 8) { 6895853e133SVivek Gautam case USB_DT_DEVICE: 6905853e133SVivek Gautam debug("USB_DT_DEVICE request\n"); 6915853e133SVivek Gautam srcptr = &descriptor.device; 6925853e133SVivek Gautam srclen = 0x12; 6935853e133SVivek Gautam break; 6945853e133SVivek Gautam case USB_DT_CONFIG: 6955853e133SVivek Gautam debug("USB_DT_CONFIG config\n"); 6965853e133SVivek Gautam srcptr = &descriptor.config; 6975853e133SVivek Gautam srclen = 0x19; 6985853e133SVivek Gautam break; 6995853e133SVivek Gautam case USB_DT_STRING: 7005853e133SVivek Gautam debug("USB_DT_STRING config\n"); 7015853e133SVivek Gautam switch (le16_to_cpu(req->value) & 0xff) { 7025853e133SVivek Gautam case 0: /* Language */ 7035853e133SVivek Gautam srcptr = "\4\3\11\4"; 7045853e133SVivek Gautam srclen = 4; 7055853e133SVivek Gautam break; 7065853e133SVivek Gautam case 1: /* Vendor String */ 707f161c178SSimon Glass srcptr = "\16\3U\0-\0B\0o\0o\0t\0"; 7085853e133SVivek Gautam srclen = 14; 7095853e133SVivek Gautam break; 7105853e133SVivek Gautam case 2: /* Product Name */ 7115853e133SVivek Gautam srcptr = "\52\3X\0H\0C\0I\0 " 7125853e133SVivek Gautam "\0H\0o\0s\0t\0 " 7135853e133SVivek Gautam "\0C\0o\0n\0t\0r\0o\0l\0l\0e\0r\0"; 7145853e133SVivek Gautam srclen = 42; 7155853e133SVivek Gautam break; 7165853e133SVivek Gautam default: 7175853e133SVivek Gautam printf("unknown value DT_STRING %x\n", 7185853e133SVivek Gautam le16_to_cpu(req->value)); 7195853e133SVivek Gautam goto unknown; 7205853e133SVivek Gautam } 7215853e133SVivek Gautam break; 7225853e133SVivek Gautam default: 7235853e133SVivek Gautam printf("unknown value %x\n", le16_to_cpu(req->value)); 7245853e133SVivek Gautam goto unknown; 7255853e133SVivek Gautam } 7265853e133SVivek Gautam break; 7275853e133SVivek Gautam case USB_REQ_GET_DESCRIPTOR | ((USB_DIR_IN | USB_RT_HUB) << 8): 7285853e133SVivek Gautam switch (le16_to_cpu(req->value) >> 8) { 7295853e133SVivek Gautam case USB_DT_HUB: 730*f3421196SBin Meng case USB_DT_SS_HUB: 7315853e133SVivek Gautam debug("USB_DT_HUB config\n"); 7325853e133SVivek Gautam srcptr = &descriptor.hub; 7335853e133SVivek Gautam srclen = 0x8; 7345853e133SVivek Gautam break; 7355853e133SVivek Gautam default: 7365853e133SVivek Gautam printf("unknown value %x\n", le16_to_cpu(req->value)); 7375853e133SVivek Gautam goto unknown; 7385853e133SVivek Gautam } 7395853e133SVivek Gautam break; 7405853e133SVivek Gautam case USB_REQ_SET_ADDRESS | (USB_RECIP_DEVICE << 8): 7415853e133SVivek Gautam debug("USB_REQ_SET_ADDRESS\n"); 7425853e133SVivek Gautam ctrl->rootdev = le16_to_cpu(req->value); 7435853e133SVivek Gautam break; 7445853e133SVivek Gautam case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: 7455853e133SVivek Gautam /* Do nothing */ 7465853e133SVivek Gautam break; 7475853e133SVivek Gautam case USB_REQ_GET_STATUS | ((USB_DIR_IN | USB_RT_HUB) << 8): 7485853e133SVivek Gautam tmpbuf[0] = 1; /* USB_STATUS_SELFPOWERED */ 7495853e133SVivek Gautam tmpbuf[1] = 0; 7505853e133SVivek Gautam srcptr = tmpbuf; 7515853e133SVivek Gautam srclen = 2; 7525853e133SVivek Gautam break; 7535853e133SVivek Gautam case USB_REQ_GET_STATUS | ((USB_RT_PORT | USB_DIR_IN) << 8): 7545853e133SVivek Gautam memset(tmpbuf, 0, 4); 7555853e133SVivek Gautam reg = xhci_readl(status_reg); 7565853e133SVivek Gautam if (reg & PORT_CONNECT) { 7575853e133SVivek Gautam tmpbuf[0] |= USB_PORT_STAT_CONNECTION; 7585853e133SVivek Gautam switch (reg & DEV_SPEED_MASK) { 7595853e133SVivek Gautam case XDEV_FS: 7605853e133SVivek Gautam debug("SPEED = FULLSPEED\n"); 7615853e133SVivek Gautam break; 7625853e133SVivek Gautam case XDEV_LS: 7635853e133SVivek Gautam debug("SPEED = LOWSPEED\n"); 7645853e133SVivek Gautam tmpbuf[1] |= USB_PORT_STAT_LOW_SPEED >> 8; 7655853e133SVivek Gautam break; 7665853e133SVivek Gautam case XDEV_HS: 7675853e133SVivek Gautam debug("SPEED = HIGHSPEED\n"); 7685853e133SVivek Gautam tmpbuf[1] |= USB_PORT_STAT_HIGH_SPEED >> 8; 7695853e133SVivek Gautam break; 7705853e133SVivek Gautam case XDEV_SS: 7715853e133SVivek Gautam debug("SPEED = SUPERSPEED\n"); 7725853e133SVivek Gautam tmpbuf[1] |= USB_PORT_STAT_SUPER_SPEED >> 8; 7735853e133SVivek Gautam break; 7745853e133SVivek Gautam } 7755853e133SVivek Gautam } 7765853e133SVivek Gautam if (reg & PORT_PE) 7775853e133SVivek Gautam tmpbuf[0] |= USB_PORT_STAT_ENABLE; 7785853e133SVivek Gautam if ((reg & PORT_PLS_MASK) == XDEV_U3) 7795853e133SVivek Gautam tmpbuf[0] |= USB_PORT_STAT_SUSPEND; 7805853e133SVivek Gautam if (reg & PORT_OC) 7815853e133SVivek Gautam tmpbuf[0] |= USB_PORT_STAT_OVERCURRENT; 7825853e133SVivek Gautam if (reg & PORT_RESET) 7835853e133SVivek Gautam tmpbuf[0] |= USB_PORT_STAT_RESET; 7845853e133SVivek Gautam if (reg & PORT_POWER) 7855853e133SVivek Gautam /* 7865853e133SVivek Gautam * XXX: This Port power bit (for USB 3.0 hub) 7875853e133SVivek Gautam * we are faking in USB 2.0 hub port status; 7885853e133SVivek Gautam * since there's a change in bit positions in 7895853e133SVivek Gautam * two: 7905853e133SVivek Gautam * USB 2.0 port status PP is at position[8] 7915853e133SVivek Gautam * USB 3.0 port status PP is at position[9] 7925853e133SVivek Gautam * So, we are still keeping it at position [8] 7935853e133SVivek Gautam */ 7945853e133SVivek Gautam tmpbuf[1] |= USB_PORT_STAT_POWER >> 8; 7955853e133SVivek Gautam if (reg & PORT_CSC) 7965853e133SVivek Gautam tmpbuf[2] |= USB_PORT_STAT_C_CONNECTION; 7975853e133SVivek Gautam if (reg & PORT_PEC) 7985853e133SVivek Gautam tmpbuf[2] |= USB_PORT_STAT_C_ENABLE; 7995853e133SVivek Gautam if (reg & PORT_OCC) 8005853e133SVivek Gautam tmpbuf[2] |= USB_PORT_STAT_C_OVERCURRENT; 8015853e133SVivek Gautam if (reg & PORT_RC) 8025853e133SVivek Gautam tmpbuf[2] |= USB_PORT_STAT_C_RESET; 8035853e133SVivek Gautam 8045853e133SVivek Gautam srcptr = tmpbuf; 8055853e133SVivek Gautam srclen = 4; 8065853e133SVivek Gautam break; 8075853e133SVivek Gautam case USB_REQ_SET_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8): 8085853e133SVivek Gautam reg = xhci_readl(status_reg); 8095853e133SVivek Gautam reg = xhci_port_state_to_neutral(reg); 8105853e133SVivek Gautam switch (le16_to_cpu(req->value)) { 8115853e133SVivek Gautam case USB_PORT_FEAT_ENABLE: 8125853e133SVivek Gautam reg |= PORT_PE; 8135853e133SVivek Gautam xhci_writel(status_reg, reg); 8145853e133SVivek Gautam break; 8155853e133SVivek Gautam case USB_PORT_FEAT_POWER: 8165853e133SVivek Gautam reg |= PORT_POWER; 8175853e133SVivek Gautam xhci_writel(status_reg, reg); 8185853e133SVivek Gautam break; 8195853e133SVivek Gautam case USB_PORT_FEAT_RESET: 8205853e133SVivek Gautam reg |= PORT_RESET; 8215853e133SVivek Gautam xhci_writel(status_reg, reg); 8225853e133SVivek Gautam break; 8235853e133SVivek Gautam default: 8245853e133SVivek Gautam printf("unknown feature %x\n", le16_to_cpu(req->value)); 8255853e133SVivek Gautam goto unknown; 8265853e133SVivek Gautam } 8275853e133SVivek Gautam break; 8285853e133SVivek Gautam case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8): 8295853e133SVivek Gautam reg = xhci_readl(status_reg); 8305853e133SVivek Gautam reg = xhci_port_state_to_neutral(reg); 8315853e133SVivek Gautam switch (le16_to_cpu(req->value)) { 8325853e133SVivek Gautam case USB_PORT_FEAT_ENABLE: 8335853e133SVivek Gautam reg &= ~PORT_PE; 8345853e133SVivek Gautam break; 8355853e133SVivek Gautam case USB_PORT_FEAT_POWER: 8365853e133SVivek Gautam reg &= ~PORT_POWER; 8375853e133SVivek Gautam break; 8385853e133SVivek Gautam case USB_PORT_FEAT_C_RESET: 8395853e133SVivek Gautam case USB_PORT_FEAT_C_CONNECTION: 8405853e133SVivek Gautam case USB_PORT_FEAT_C_OVER_CURRENT: 8415853e133SVivek Gautam case USB_PORT_FEAT_C_ENABLE: 8425853e133SVivek Gautam xhci_clear_port_change_bit((le16_to_cpu(req->value)), 8435853e133SVivek Gautam le16_to_cpu(req->index), 8445853e133SVivek Gautam status_reg, reg); 8455853e133SVivek Gautam break; 8465853e133SVivek Gautam default: 8475853e133SVivek Gautam printf("unknown feature %x\n", le16_to_cpu(req->value)); 8485853e133SVivek Gautam goto unknown; 8495853e133SVivek Gautam } 8505853e133SVivek Gautam xhci_writel(status_reg, reg); 8515853e133SVivek Gautam break; 8525853e133SVivek Gautam default: 8535853e133SVivek Gautam puts("Unknown request\n"); 8545853e133SVivek Gautam goto unknown; 8555853e133SVivek Gautam } 8565853e133SVivek Gautam 8575853e133SVivek Gautam debug("scrlen = %d\n req->length = %d\n", 8585853e133SVivek Gautam srclen, le16_to_cpu(req->length)); 8595853e133SVivek Gautam 860b4141195SMasahiro Yamada len = min(srclen, (int)le16_to_cpu(req->length)); 8615853e133SVivek Gautam 8625853e133SVivek Gautam if (srcptr != NULL && len > 0) 8635853e133SVivek Gautam memcpy(buffer, srcptr, len); 8645853e133SVivek Gautam else 8655853e133SVivek Gautam debug("Len is 0\n"); 8665853e133SVivek Gautam 8675853e133SVivek Gautam udev->act_len = len; 8685853e133SVivek Gautam udev->status = 0; 8695853e133SVivek Gautam 8705853e133SVivek Gautam return 0; 8715853e133SVivek Gautam 8725853e133SVivek Gautam unknown: 8735853e133SVivek Gautam udev->act_len = 0; 8745853e133SVivek Gautam udev->status = USB_ST_STALLED; 8755853e133SVivek Gautam 8765853e133SVivek Gautam return -ENODEV; 8775853e133SVivek Gautam } 8785853e133SVivek Gautam 8795853e133SVivek Gautam /** 8805853e133SVivek Gautam * Submits the INT request to XHCI Host cotroller 8815853e133SVivek Gautam * 8825853e133SVivek Gautam * @param udev pointer to the USB device 8835853e133SVivek Gautam * @param pipe contains the DIR_IN or OUT , devnum 8845853e133SVivek Gautam * @param buffer buffer to be read/written based on the request 8855853e133SVivek Gautam * @param length length of the buffer 8865853e133SVivek Gautam * @param interval interval of the interrupt 8875853e133SVivek Gautam * @return 0 8885853e133SVivek Gautam */ 889a5762fe0SSimon Glass static int _xhci_submit_int_msg(struct usb_device *udev, unsigned long pipe, 890a5762fe0SSimon Glass void *buffer, int length, int interval) 8915853e133SVivek Gautam { 8925853e133SVivek Gautam /* 8935853e133SVivek Gautam * TODO: Not addressing any interrupt type transfer requests 8945853e133SVivek Gautam * Add support for it later. 8955853e133SVivek Gautam */ 8965853e133SVivek Gautam return -EINVAL; 8975853e133SVivek Gautam } 8985853e133SVivek Gautam 8995853e133SVivek Gautam /** 9005853e133SVivek Gautam * submit the BULK type of request to the USB Device 9015853e133SVivek Gautam * 9025853e133SVivek Gautam * @param udev pointer to the USB device 9035853e133SVivek Gautam * @param pipe contains the DIR_IN or OUT , devnum 9045853e133SVivek Gautam * @param buffer buffer to be read/written based on the request 9055853e133SVivek Gautam * @param length length of the buffer 9065853e133SVivek Gautam * @return returns 0 if successful else -1 on failure 9075853e133SVivek Gautam */ 908a5762fe0SSimon Glass static int _xhci_submit_bulk_msg(struct usb_device *udev, unsigned long pipe, 909a5762fe0SSimon Glass void *buffer, int length) 9105853e133SVivek Gautam { 9115853e133SVivek Gautam if (usb_pipetype(pipe) != PIPE_BULK) { 9125853e133SVivek Gautam printf("non-bulk pipe (type=%lu)", usb_pipetype(pipe)); 9135853e133SVivek Gautam return -EINVAL; 9145853e133SVivek Gautam } 9155853e133SVivek Gautam 9165853e133SVivek Gautam return xhci_bulk_tx(udev, pipe, length, buffer); 9175853e133SVivek Gautam } 9185853e133SVivek Gautam 9195853e133SVivek Gautam /** 9205853e133SVivek Gautam * submit the control type of request to the Root hub/Device based on the devnum 9215853e133SVivek Gautam * 9225853e133SVivek Gautam * @param udev pointer to the USB device 9235853e133SVivek Gautam * @param pipe contains the DIR_IN or OUT , devnum 9245853e133SVivek Gautam * @param buffer buffer to be read/written based on the request 9255853e133SVivek Gautam * @param length length of the buffer 9265853e133SVivek Gautam * @param setup Request type 9275dd75e3bSSimon Glass * @param root_portnr Root port number that this device is on 9285853e133SVivek Gautam * @return returns 0 if successful else -1 on failure 9295853e133SVivek Gautam */ 9305dd75e3bSSimon Glass static int _xhci_submit_control_msg(struct usb_device *udev, unsigned long pipe, 9315dd75e3bSSimon Glass void *buffer, int length, 9325dd75e3bSSimon Glass struct devrequest *setup, int root_portnr) 9335853e133SVivek Gautam { 9347c1deec0SSimon Glass struct xhci_ctrl *ctrl = xhci_get_ctrl(udev); 9355853e133SVivek Gautam int ret = 0; 9365853e133SVivek Gautam 9375853e133SVivek Gautam if (usb_pipetype(pipe) != PIPE_CONTROL) { 9385853e133SVivek Gautam printf("non-control pipe (type=%lu)", usb_pipetype(pipe)); 9395853e133SVivek Gautam return -EINVAL; 9405853e133SVivek Gautam } 9415853e133SVivek Gautam 9425853e133SVivek Gautam if (usb_pipedevice(pipe) == ctrl->rootdev) 9435853e133SVivek Gautam return xhci_submit_root(udev, pipe, buffer, setup); 9445853e133SVivek Gautam 9451b108880STed Chen if (setup->request == USB_REQ_SET_ADDRESS && 9461b108880STed Chen (setup->requesttype & USB_TYPE_MASK) == USB_TYPE_STANDARD) 9475dd75e3bSSimon Glass return xhci_address_device(udev, root_portnr); 9485853e133SVivek Gautam 9491b108880STed Chen if (setup->request == USB_REQ_SET_CONFIGURATION && 9501b108880STed Chen (setup->requesttype & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 9515853e133SVivek Gautam ret = xhci_set_configuration(udev); 9525853e133SVivek Gautam if (ret) { 9535853e133SVivek Gautam puts("Failed to configure xHCI endpoint\n"); 9545853e133SVivek Gautam return ret; 9555853e133SVivek Gautam } 9565853e133SVivek Gautam } 9575853e133SVivek Gautam 9585853e133SVivek Gautam return xhci_ctrl_tx(udev, pipe, setup, length, buffer); 9595853e133SVivek Gautam } 9605853e133SVivek Gautam 961779d1263SSimon Glass static int xhci_lowlevel_init(struct xhci_ctrl *ctrl) 9625853e133SVivek Gautam { 963779d1263SSimon Glass struct xhci_hccr *hccr; 964779d1263SSimon Glass struct xhci_hcor *hcor; 9655853e133SVivek Gautam uint32_t val; 9665853e133SVivek Gautam uint32_t val2; 9675853e133SVivek Gautam uint32_t reg; 9685853e133SVivek Gautam 969779d1263SSimon Glass hccr = ctrl->hccr; 970779d1263SSimon Glass hcor = ctrl->hcor; 9715853e133SVivek Gautam /* 9725853e133SVivek Gautam * Program the Number of Device Slots Enabled field in the CONFIG 9735853e133SVivek Gautam * register with the max value of slots the HC can handle. 9745853e133SVivek Gautam */ 9755853e133SVivek Gautam val = (xhci_readl(&hccr->cr_hcsparams1) & HCS_SLOTS_MASK); 9765853e133SVivek Gautam val2 = xhci_readl(&hcor->or_config); 9775853e133SVivek Gautam val |= (val2 & ~HCS_SLOTS_MASK); 9785853e133SVivek Gautam xhci_writel(&hcor->or_config, val); 9795853e133SVivek Gautam 9805853e133SVivek Gautam /* initializing xhci data structures */ 9815853e133SVivek Gautam if (xhci_mem_init(ctrl, hccr, hcor) < 0) 9825853e133SVivek Gautam return -ENOMEM; 9835853e133SVivek Gautam 9845853e133SVivek Gautam reg = xhci_readl(&hccr->cr_hcsparams1); 9855853e133SVivek Gautam descriptor.hub.bNbrPorts = ((reg & HCS_MAX_PORTS_MASK) >> 9865853e133SVivek Gautam HCS_MAX_PORTS_SHIFT); 9875853e133SVivek Gautam printf("Register %x NbrPorts %d\n", reg, descriptor.hub.bNbrPorts); 9885853e133SVivek Gautam 9895853e133SVivek Gautam /* Port Indicators */ 9905853e133SVivek Gautam reg = xhci_readl(&hccr->cr_hccparams); 9915853e133SVivek Gautam if (HCS_INDICATOR(reg)) 9925853e133SVivek Gautam put_unaligned(get_unaligned(&descriptor.hub.wHubCharacteristics) 9935853e133SVivek Gautam | 0x80, &descriptor.hub.wHubCharacteristics); 9945853e133SVivek Gautam 9955853e133SVivek Gautam /* Port Power Control */ 9965853e133SVivek Gautam if (HCC_PPC(reg)) 9975853e133SVivek Gautam put_unaligned(get_unaligned(&descriptor.hub.wHubCharacteristics) 9985853e133SVivek Gautam | 0x01, &descriptor.hub.wHubCharacteristics); 9995853e133SVivek Gautam 10005853e133SVivek Gautam if (xhci_start(hcor)) { 10015853e133SVivek Gautam xhci_reset(hcor); 10025853e133SVivek Gautam return -ENODEV; 10035853e133SVivek Gautam } 10045853e133SVivek Gautam 10055853e133SVivek Gautam /* Zero'ing IRQ control register and IRQ pending register */ 10065853e133SVivek Gautam xhci_writel(&ctrl->ir_set->irq_control, 0x0); 10075853e133SVivek Gautam xhci_writel(&ctrl->ir_set->irq_pending, 0x0); 10085853e133SVivek Gautam 10095853e133SVivek Gautam reg = HC_VERSION(xhci_readl(&hccr->cr_capbase)); 10105853e133SVivek Gautam printf("USB XHCI %x.%02x\n", reg >> 8, reg & 0xff); 10115853e133SVivek Gautam 1012779d1263SSimon Glass return 0; 1013779d1263SSimon Glass } 1014779d1263SSimon Glass 1015779d1263SSimon Glass static int xhci_lowlevel_stop(struct xhci_ctrl *ctrl) 1016779d1263SSimon Glass { 1017779d1263SSimon Glass u32 temp; 1018779d1263SSimon Glass 1019779d1263SSimon Glass xhci_reset(ctrl->hcor); 1020779d1263SSimon Glass 1021779d1263SSimon Glass debug("// Disabling event ring interrupts\n"); 1022779d1263SSimon Glass temp = xhci_readl(&ctrl->hcor->or_usbsts); 1023779d1263SSimon Glass xhci_writel(&ctrl->hcor->or_usbsts, temp & ~STS_EINT); 1024779d1263SSimon Glass temp = xhci_readl(&ctrl->ir_set->irq_pending); 1025779d1263SSimon Glass xhci_writel(&ctrl->ir_set->irq_pending, ER_IRQ_DISABLE(temp)); 10265853e133SVivek Gautam 10275853e133SVivek Gautam return 0; 10285853e133SVivek Gautam } 10295853e133SVivek Gautam 1030a5762fe0SSimon Glass #ifndef CONFIG_DM_USB 10315dd75e3bSSimon Glass int submit_control_msg(struct usb_device *udev, unsigned long pipe, 10325dd75e3bSSimon Glass void *buffer, int length, struct devrequest *setup) 10335dd75e3bSSimon Glass { 10345dd75e3bSSimon Glass struct usb_device *hop = udev; 10355dd75e3bSSimon Glass 10365dd75e3bSSimon Glass if (hop->parent) 10375dd75e3bSSimon Glass while (hop->parent->parent) 10385dd75e3bSSimon Glass hop = hop->parent; 10395dd75e3bSSimon Glass 10405dd75e3bSSimon Glass return _xhci_submit_control_msg(udev, pipe, buffer, length, setup, 10415dd75e3bSSimon Glass hop->portnr); 10425dd75e3bSSimon Glass } 10435dd75e3bSSimon Glass 1044a5762fe0SSimon Glass int submit_bulk_msg(struct usb_device *udev, unsigned long pipe, void *buffer, 1045a5762fe0SSimon Glass int length) 1046a5762fe0SSimon Glass { 1047a5762fe0SSimon Glass return _xhci_submit_bulk_msg(udev, pipe, buffer, length); 1048a5762fe0SSimon Glass } 1049a5762fe0SSimon Glass 1050a5762fe0SSimon Glass int submit_int_msg(struct usb_device *udev, unsigned long pipe, void *buffer, 1051a5762fe0SSimon Glass int length, int interval) 1052a5762fe0SSimon Glass { 1053a5762fe0SSimon Glass return _xhci_submit_int_msg(udev, pipe, buffer, length, interval); 1054a5762fe0SSimon Glass } 1055a5762fe0SSimon Glass 10565853e133SVivek Gautam /** 1057779d1263SSimon Glass * Intialises the XHCI host controller 1058779d1263SSimon Glass * and allocates the necessary data structures 1059779d1263SSimon Glass * 1060779d1263SSimon Glass * @param index index to the host controller data structure 1061779d1263SSimon Glass * @return pointer to the intialised controller 1062779d1263SSimon Glass */ 1063779d1263SSimon Glass int usb_lowlevel_init(int index, enum usb_init_type init, void **controller) 1064779d1263SSimon Glass { 1065779d1263SSimon Glass struct xhci_hccr *hccr; 1066779d1263SSimon Glass struct xhci_hcor *hcor; 1067779d1263SSimon Glass struct xhci_ctrl *ctrl; 1068779d1263SSimon Glass int ret; 1069779d1263SSimon Glass 1070a5ccda47SSergey Temerkhanov *controller = NULL; 1071a5ccda47SSergey Temerkhanov 1072779d1263SSimon Glass if (xhci_hcd_init(index, &hccr, (struct xhci_hcor **)&hcor) != 0) 1073779d1263SSimon Glass return -ENODEV; 1074779d1263SSimon Glass 1075779d1263SSimon Glass if (xhci_reset(hcor) != 0) 1076779d1263SSimon Glass return -ENODEV; 1077779d1263SSimon Glass 1078779d1263SSimon Glass ctrl = &xhcic[index]; 1079779d1263SSimon Glass 1080779d1263SSimon Glass ctrl->hccr = hccr; 1081779d1263SSimon Glass ctrl->hcor = hcor; 1082779d1263SSimon Glass 1083779d1263SSimon Glass ret = xhci_lowlevel_init(ctrl); 1084779d1263SSimon Glass 1085a5ccda47SSergey Temerkhanov if (ret) { 1086a5ccda47SSergey Temerkhanov ctrl->hccr = NULL; 1087a5ccda47SSergey Temerkhanov ctrl->hcor = NULL; 1088a5ccda47SSergey Temerkhanov } else { 1089779d1263SSimon Glass *controller = &xhcic[index]; 1090a5ccda47SSergey Temerkhanov } 1091779d1263SSimon Glass 1092779d1263SSimon Glass return ret; 1093779d1263SSimon Glass } 1094779d1263SSimon Glass 1095779d1263SSimon Glass /** 10965853e133SVivek Gautam * Stops the XHCI host controller 10975853e133SVivek Gautam * and cleans up all the related data structures 10985853e133SVivek Gautam * 10995853e133SVivek Gautam * @param index index to the host controller data structure 11005853e133SVivek Gautam * @return none 11015853e133SVivek Gautam */ 11025853e133SVivek Gautam int usb_lowlevel_stop(int index) 11035853e133SVivek Gautam { 11045853e133SVivek Gautam struct xhci_ctrl *ctrl = (xhcic + index); 11055853e133SVivek Gautam 1106a5ccda47SSergey Temerkhanov if (ctrl->hcor) { 1107779d1263SSimon Glass xhci_lowlevel_stop(ctrl); 11085853e133SVivek Gautam xhci_hcd_stop(index); 11095853e133SVivek Gautam xhci_cleanup(ctrl); 1110a5ccda47SSergey Temerkhanov } 11115853e133SVivek Gautam 11125853e133SVivek Gautam return 0; 11135853e133SVivek Gautam } 1114a5762fe0SSimon Glass #endif /* CONFIG_DM_USB */ 1115a5762fe0SSimon Glass 1116a5762fe0SSimon Glass #ifdef CONFIG_DM_USB 1117a5762fe0SSimon Glass /* 1118a5762fe0SSimon Glass static struct usb_device *get_usb_device(struct udevice *dev) 1119a5762fe0SSimon Glass { 1120a5762fe0SSimon Glass struct usb_device *udev; 1121a5762fe0SSimon Glass 1122a5762fe0SSimon Glass if (device_get_uclass_id(dev) == UCLASS_USB) 1123a5762fe0SSimon Glass udev = dev_get_uclass_priv(dev); 1124a5762fe0SSimon Glass else 1125bcbe3d15SSimon Glass udev = dev_get_parent_priv(dev); 1126a5762fe0SSimon Glass 1127a5762fe0SSimon Glass return udev; 1128a5762fe0SSimon Glass } 1129a5762fe0SSimon Glass */ 1130a5762fe0SSimon Glass static bool is_root_hub(struct udevice *dev) 1131a5762fe0SSimon Glass { 1132a5762fe0SSimon Glass if (device_get_uclass_id(dev->parent) != UCLASS_USB_HUB) 1133a5762fe0SSimon Glass return true; 1134a5762fe0SSimon Glass 1135a5762fe0SSimon Glass return false; 1136a5762fe0SSimon Glass } 1137a5762fe0SSimon Glass 1138a5762fe0SSimon Glass static int xhci_submit_control_msg(struct udevice *dev, struct usb_device *udev, 1139a5762fe0SSimon Glass unsigned long pipe, void *buffer, int length, 1140a5762fe0SSimon Glass struct devrequest *setup) 1141a5762fe0SSimon Glass { 1142a5762fe0SSimon Glass struct usb_device *uhop; 1143a5762fe0SSimon Glass struct udevice *hub; 1144a5762fe0SSimon Glass int root_portnr = 0; 1145a5762fe0SSimon Glass 1146a5762fe0SSimon Glass debug("%s: dev='%s', udev=%p, udev->dev='%s', portnr=%d\n", __func__, 1147a5762fe0SSimon Glass dev->name, udev, udev->dev->name, udev->portnr); 1148a5762fe0SSimon Glass hub = udev->dev; 1149a5762fe0SSimon Glass if (device_get_uclass_id(hub) == UCLASS_USB_HUB) { 1150a5762fe0SSimon Glass /* Figure out our port number on the root hub */ 1151a5762fe0SSimon Glass if (is_root_hub(hub)) { 1152a5762fe0SSimon Glass root_portnr = udev->portnr; 1153a5762fe0SSimon Glass } else { 1154a5762fe0SSimon Glass while (!is_root_hub(hub->parent)) 1155a5762fe0SSimon Glass hub = hub->parent; 1156bcbe3d15SSimon Glass uhop = dev_get_parent_priv(hub); 1157a5762fe0SSimon Glass root_portnr = uhop->portnr; 1158a5762fe0SSimon Glass } 1159a5762fe0SSimon Glass } 1160a5762fe0SSimon Glass /* 1161a5762fe0SSimon Glass struct usb_device *hop = udev; 1162a5762fe0SSimon Glass 1163a5762fe0SSimon Glass if (hop->parent) 1164a5762fe0SSimon Glass while (hop->parent->parent) 1165a5762fe0SSimon Glass hop = hop->parent; 1166a5762fe0SSimon Glass */ 1167a5762fe0SSimon Glass return _xhci_submit_control_msg(udev, pipe, buffer, length, setup, 1168a5762fe0SSimon Glass root_portnr); 1169a5762fe0SSimon Glass } 1170a5762fe0SSimon Glass 1171a5762fe0SSimon Glass static int xhci_submit_bulk_msg(struct udevice *dev, struct usb_device *udev, 1172a5762fe0SSimon Glass unsigned long pipe, void *buffer, int length) 1173a5762fe0SSimon Glass { 1174a5762fe0SSimon Glass debug("%s: dev='%s', udev=%p\n", __func__, dev->name, udev); 1175a5762fe0SSimon Glass return _xhci_submit_bulk_msg(udev, pipe, buffer, length); 1176a5762fe0SSimon Glass } 1177a5762fe0SSimon Glass 1178a5762fe0SSimon Glass static int xhci_submit_int_msg(struct udevice *dev, struct usb_device *udev, 1179a5762fe0SSimon Glass unsigned long pipe, void *buffer, int length, 1180a5762fe0SSimon Glass int interval) 1181a5762fe0SSimon Glass { 1182a5762fe0SSimon Glass debug("%s: dev='%s', udev=%p\n", __func__, dev->name, udev); 1183a5762fe0SSimon Glass return _xhci_submit_int_msg(udev, pipe, buffer, length, interval); 1184a5762fe0SSimon Glass } 1185a5762fe0SSimon Glass 1186a5762fe0SSimon Glass static int xhci_alloc_device(struct udevice *dev, struct usb_device *udev) 1187a5762fe0SSimon Glass { 1188a5762fe0SSimon Glass debug("%s: dev='%s', udev=%p\n", __func__, dev->name, udev); 1189a5762fe0SSimon Glass return _xhci_alloc_device(udev); 1190a5762fe0SSimon Glass } 1191a5762fe0SSimon Glass 1192a5762fe0SSimon Glass int xhci_register(struct udevice *dev, struct xhci_hccr *hccr, 1193a5762fe0SSimon Glass struct xhci_hcor *hcor) 1194a5762fe0SSimon Glass { 1195a5762fe0SSimon Glass struct xhci_ctrl *ctrl = dev_get_priv(dev); 1196a5762fe0SSimon Glass struct usb_bus_priv *priv = dev_get_uclass_priv(dev); 1197a5762fe0SSimon Glass int ret; 1198a5762fe0SSimon Glass 1199a5762fe0SSimon Glass debug("%s: dev='%s', ctrl=%p, hccr=%p, hcor=%p\n", __func__, dev->name, 1200a5762fe0SSimon Glass ctrl, hccr, hcor); 1201a5762fe0SSimon Glass 1202a5762fe0SSimon Glass ctrl->dev = dev; 1203a5762fe0SSimon Glass 1204a5762fe0SSimon Glass /* 1205a5762fe0SSimon Glass * XHCI needs to issue a Address device command to setup 1206a5762fe0SSimon Glass * proper device context structures, before it can interact 1207a5762fe0SSimon Glass * with the device. So a get_descriptor will fail before any 1208a5762fe0SSimon Glass * of that is done for XHCI unlike EHCI. 1209a5762fe0SSimon Glass */ 1210a5762fe0SSimon Glass priv->desc_before_addr = false; 1211a5762fe0SSimon Glass 1212a5762fe0SSimon Glass ret = xhci_reset(hcor); 1213a5762fe0SSimon Glass if (ret) 1214a5762fe0SSimon Glass goto err; 1215a5762fe0SSimon Glass 1216a5762fe0SSimon Glass ctrl->hccr = hccr; 1217a5762fe0SSimon Glass ctrl->hcor = hcor; 1218a5762fe0SSimon Glass ret = xhci_lowlevel_init(ctrl); 1219a5762fe0SSimon Glass if (ret) 1220a5762fe0SSimon Glass goto err; 1221a5762fe0SSimon Glass 1222a5762fe0SSimon Glass return 0; 1223a5762fe0SSimon Glass err: 1224a5762fe0SSimon Glass free(ctrl); 1225a5762fe0SSimon Glass debug("%s: failed, ret=%d\n", __func__, ret); 1226a5762fe0SSimon Glass return ret; 1227a5762fe0SSimon Glass } 1228a5762fe0SSimon Glass 1229a5762fe0SSimon Glass int xhci_deregister(struct udevice *dev) 1230a5762fe0SSimon Glass { 1231a5762fe0SSimon Glass struct xhci_ctrl *ctrl = dev_get_priv(dev); 1232a5762fe0SSimon Glass 1233a5762fe0SSimon Glass xhci_lowlevel_stop(ctrl); 1234a5762fe0SSimon Glass xhci_cleanup(ctrl); 1235a5762fe0SSimon Glass 1236a5762fe0SSimon Glass return 0; 1237a5762fe0SSimon Glass } 1238a5762fe0SSimon Glass 1239a5762fe0SSimon Glass struct dm_usb_ops xhci_usb_ops = { 1240a5762fe0SSimon Glass .control = xhci_submit_control_msg, 1241a5762fe0SSimon Glass .bulk = xhci_submit_bulk_msg, 1242a5762fe0SSimon Glass .interrupt = xhci_submit_int_msg, 1243a5762fe0SSimon Glass .alloc_device = xhci_alloc_device, 1244a5762fe0SSimon Glass }; 1245a5762fe0SSimon Glass 1246a5762fe0SSimon Glass #endif 1247