Kevin O'Connor | 151d034 | 2014-01-27 12:25:35 -0500 | [diff] [blame] | 1 | // Code for handling XHCI "Super speed" USB controllers. |
| 2 | // |
| 3 | // Copyright (C) 2013 Gerd Hoffmann <kraxel@redhat.com> |
| 4 | // Copyright (C) 2014 Kevin O'Connor <kevin@koconnor.net> |
| 5 | // |
| 6 | // This file may be distributed under the terms of the GNU LGPLv3 license. |
| 7 | |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 8 | #include "config.h" // CONFIG_* |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 9 | #include "malloc.h" // memalign_low |
Kevin O'Connor | 347f363 | 2013-12-27 18:30:02 -0500 | [diff] [blame] | 10 | #include "memmap.h" // PAGE_SIZE |
| 11 | #include "output.h" // dprintf |
Kevin O'Connor | 4d8510c | 2016-02-03 01:28:20 -0500 | [diff] [blame] | 12 | #include "pcidevice.h" // foreachpci |
Kevin O'Connor | ec443ff | 2013-12-05 18:43:20 -0500 | [diff] [blame] | 13 | #include "pci_ids.h" // PCI_CLASS_SERIAL_USB_XHCI |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 14 | #include "pci_regs.h" // PCI_BASE_ADDRESS_0 |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 15 | #include "string.h" // memcpy |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 16 | #include "usb.h" // struct usb_s |
| 17 | #include "usb-xhci.h" // struct ehci_qh |
Kevin O'Connor | 347f363 | 2013-12-27 18:30:02 -0500 | [diff] [blame] | 18 | #include "util.h" // timer_calc |
| 19 | #include "x86.h" // readl |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 20 | |
| 21 | // -------------------------------------------------------------- |
| 22 | // configuration |
| 23 | |
| 24 | #define XHCI_RING_ITEMS 16 |
| 25 | #define XHCI_RING_SIZE (XHCI_RING_ITEMS*sizeof(struct xhci_trb)) |
| 26 | |
| 27 | /* |
| 28 | * xhci_ring structs are allocated with XHCI_RING_SIZE alignment, |
| 29 | * then we can get it from a trb pointer (provided by evt ring). |
| 30 | */ |
| 31 | #define XHCI_RING(_trb) \ |
| 32 | ((struct xhci_ring*)((u32)(_trb) & ~(XHCI_RING_SIZE-1))) |
| 33 | |
| 34 | // -------------------------------------------------------------- |
| 35 | // bit definitions |
| 36 | |
| 37 | #define XHCI_CMD_RS (1<<0) |
| 38 | #define XHCI_CMD_HCRST (1<<1) |
| 39 | #define XHCI_CMD_INTE (1<<2) |
| 40 | #define XHCI_CMD_HSEE (1<<3) |
| 41 | #define XHCI_CMD_LHCRST (1<<7) |
| 42 | #define XHCI_CMD_CSS (1<<8) |
| 43 | #define XHCI_CMD_CRS (1<<9) |
| 44 | #define XHCI_CMD_EWE (1<<10) |
| 45 | #define XHCI_CMD_EU3S (1<<11) |
| 46 | |
| 47 | #define XHCI_STS_HCH (1<<0) |
| 48 | #define XHCI_STS_HSE (1<<2) |
| 49 | #define XHCI_STS_EINT (1<<3) |
| 50 | #define XHCI_STS_PCD (1<<4) |
| 51 | #define XHCI_STS_SSS (1<<8) |
| 52 | #define XHCI_STS_RSS (1<<9) |
| 53 | #define XHCI_STS_SRE (1<<10) |
| 54 | #define XHCI_STS_CNR (1<<11) |
| 55 | #define XHCI_STS_HCE (1<<12) |
| 56 | |
| 57 | #define XHCI_PORTSC_CCS (1<<0) |
| 58 | #define XHCI_PORTSC_PED (1<<1) |
| 59 | #define XHCI_PORTSC_OCA (1<<3) |
| 60 | #define XHCI_PORTSC_PR (1<<4) |
| 61 | #define XHCI_PORTSC_PLS_SHIFT 5 |
| 62 | #define XHCI_PORTSC_PLS_MASK 0xf |
| 63 | #define XHCI_PORTSC_PP (1<<9) |
| 64 | #define XHCI_PORTSC_SPEED_SHIFT 10 |
| 65 | #define XHCI_PORTSC_SPEED_MASK 0xf |
| 66 | #define XHCI_PORTSC_SPEED_FULL (1<<10) |
| 67 | #define XHCI_PORTSC_SPEED_LOW (2<<10) |
| 68 | #define XHCI_PORTSC_SPEED_HIGH (3<<10) |
| 69 | #define XHCI_PORTSC_SPEED_SUPER (4<<10) |
| 70 | #define XHCI_PORTSC_PIC_SHIFT 14 |
| 71 | #define XHCI_PORTSC_PIC_MASK 0x3 |
| 72 | #define XHCI_PORTSC_LWS (1<<16) |
| 73 | #define XHCI_PORTSC_CSC (1<<17) |
| 74 | #define XHCI_PORTSC_PEC (1<<18) |
| 75 | #define XHCI_PORTSC_WRC (1<<19) |
| 76 | #define XHCI_PORTSC_OCC (1<<20) |
| 77 | #define XHCI_PORTSC_PRC (1<<21) |
| 78 | #define XHCI_PORTSC_PLC (1<<22) |
| 79 | #define XHCI_PORTSC_CEC (1<<23) |
| 80 | #define XHCI_PORTSC_CAS (1<<24) |
| 81 | #define XHCI_PORTSC_WCE (1<<25) |
| 82 | #define XHCI_PORTSC_WDE (1<<26) |
| 83 | #define XHCI_PORTSC_WOE (1<<27) |
| 84 | #define XHCI_PORTSC_DR (1<<30) |
| 85 | #define XHCI_PORTSC_WPR (1<<31) |
| 86 | |
| 87 | #define TRB_C (1<<0) |
| 88 | #define TRB_TYPE_SHIFT 10 |
| 89 | #define TRB_TYPE_MASK 0x3f |
| 90 | #define TRB_TYPE(t) (((t) >> TRB_TYPE_SHIFT) & TRB_TYPE_MASK) |
| 91 | |
| 92 | #define TRB_EV_ED (1<<2) |
| 93 | |
| 94 | #define TRB_TR_ENT (1<<1) |
| 95 | #define TRB_TR_ISP (1<<2) |
| 96 | #define TRB_TR_NS (1<<3) |
| 97 | #define TRB_TR_CH (1<<4) |
| 98 | #define TRB_TR_IOC (1<<5) |
| 99 | #define TRB_TR_IDT (1<<6) |
| 100 | #define TRB_TR_TBC_SHIFT 7 |
| 101 | #define TRB_TR_TBC_MASK 0x3 |
| 102 | #define TRB_TR_BEI (1<<9) |
| 103 | #define TRB_TR_TLBPC_SHIFT 16 |
| 104 | #define TRB_TR_TLBPC_MASK 0xf |
| 105 | #define TRB_TR_FRAMEID_SHIFT 20 |
| 106 | #define TRB_TR_FRAMEID_MASK 0x7ff |
| 107 | #define TRB_TR_SIA (1<<31) |
| 108 | |
| 109 | #define TRB_TR_DIR (1<<16) |
| 110 | |
| 111 | #define TRB_CR_SLOTID_SHIFT 24 |
| 112 | #define TRB_CR_SLOTID_MASK 0xff |
| 113 | #define TRB_CR_EPID_SHIFT 16 |
| 114 | #define TRB_CR_EPID_MASK 0x1f |
| 115 | |
| 116 | #define TRB_CR_BSR (1<<9) |
| 117 | #define TRB_CR_DC (1<<9) |
| 118 | |
| 119 | #define TRB_LK_TC (1<<1) |
| 120 | |
| 121 | #define TRB_INTR_SHIFT 22 |
| 122 | #define TRB_INTR_MASK 0x3ff |
| 123 | #define TRB_INTR(t) (((t).status >> TRB_INTR_SHIFT) & TRB_INTR_MASK) |
| 124 | |
| 125 | typedef enum TRBType { |
| 126 | TRB_RESERVED = 0, |
| 127 | TR_NORMAL, |
| 128 | TR_SETUP, |
| 129 | TR_DATA, |
| 130 | TR_STATUS, |
| 131 | TR_ISOCH, |
| 132 | TR_LINK, |
| 133 | TR_EVDATA, |
| 134 | TR_NOOP, |
| 135 | CR_ENABLE_SLOT, |
| 136 | CR_DISABLE_SLOT, |
| 137 | CR_ADDRESS_DEVICE, |
| 138 | CR_CONFIGURE_ENDPOINT, |
| 139 | CR_EVALUATE_CONTEXT, |
| 140 | CR_RESET_ENDPOINT, |
| 141 | CR_STOP_ENDPOINT, |
| 142 | CR_SET_TR_DEQUEUE, |
| 143 | CR_RESET_DEVICE, |
| 144 | CR_FORCE_EVENT, |
| 145 | CR_NEGOTIATE_BW, |
| 146 | CR_SET_LATENCY_TOLERANCE, |
| 147 | CR_GET_PORT_BANDWIDTH, |
| 148 | CR_FORCE_HEADER, |
| 149 | CR_NOOP, |
| 150 | ER_TRANSFER = 32, |
| 151 | ER_COMMAND_COMPLETE, |
| 152 | ER_PORT_STATUS_CHANGE, |
| 153 | ER_BANDWIDTH_REQUEST, |
| 154 | ER_DOORBELL, |
| 155 | ER_HOST_CONTROLLER, |
| 156 | ER_DEVICE_NOTIFICATION, |
| 157 | ER_MFINDEX_WRAP, |
| 158 | } TRBType; |
| 159 | |
| 160 | typedef enum TRBCCode { |
| 161 | CC_INVALID = 0, |
| 162 | CC_SUCCESS, |
| 163 | CC_DATA_BUFFER_ERROR, |
| 164 | CC_BABBLE_DETECTED, |
| 165 | CC_USB_TRANSACTION_ERROR, |
| 166 | CC_TRB_ERROR, |
| 167 | CC_STALL_ERROR, |
| 168 | CC_RESOURCE_ERROR, |
| 169 | CC_BANDWIDTH_ERROR, |
| 170 | CC_NO_SLOTS_ERROR, |
| 171 | CC_INVALID_STREAM_TYPE_ERROR, |
| 172 | CC_SLOT_NOT_ENABLED_ERROR, |
| 173 | CC_EP_NOT_ENABLED_ERROR, |
| 174 | CC_SHORT_PACKET, |
| 175 | CC_RING_UNDERRUN, |
| 176 | CC_RING_OVERRUN, |
| 177 | CC_VF_ER_FULL, |
| 178 | CC_PARAMETER_ERROR, |
| 179 | CC_BANDWIDTH_OVERRUN, |
| 180 | CC_CONTEXT_STATE_ERROR, |
| 181 | CC_NO_PING_RESPONSE_ERROR, |
| 182 | CC_EVENT_RING_FULL_ERROR, |
| 183 | CC_INCOMPATIBLE_DEVICE_ERROR, |
| 184 | CC_MISSED_SERVICE_ERROR, |
| 185 | CC_COMMAND_RING_STOPPED, |
| 186 | CC_COMMAND_ABORTED, |
| 187 | CC_STOPPED, |
| 188 | CC_STOPPED_LENGTH_INVALID, |
| 189 | CC_MAX_EXIT_LATENCY_TOO_LARGE_ERROR = 29, |
| 190 | CC_ISOCH_BUFFER_OVERRUN = 31, |
| 191 | CC_EVENT_LOST_ERROR, |
| 192 | CC_UNDEFINED_ERROR, |
| 193 | CC_INVALID_STREAM_ID_ERROR, |
| 194 | CC_SECONDARY_BANDWIDTH_ERROR, |
| 195 | CC_SPLIT_TRANSACTION_ERROR |
| 196 | } TRBCCode; |
| 197 | |
| 198 | enum { |
| 199 | PLS_U0 = 0, |
| 200 | PLS_U1 = 1, |
| 201 | PLS_U2 = 2, |
| 202 | PLS_U3 = 3, |
| 203 | PLS_DISABLED = 4, |
| 204 | PLS_RX_DETECT = 5, |
| 205 | PLS_INACTIVE = 6, |
| 206 | PLS_POLLING = 7, |
| 207 | PLS_RECOVERY = 8, |
| 208 | PLS_HOT_RESET = 9, |
| 209 | PLS_COMPILANCE_MODE = 10, |
| 210 | PLS_TEST_MODE = 11, |
| 211 | PLS_RESUME = 15, |
| 212 | }; |
| 213 | |
| 214 | #define xhci_get_field(data, field) \ |
| 215 | (((data) >> field##_SHIFT) & field##_MASK) |
| 216 | |
| 217 | // -------------------------------------------------------------- |
| 218 | // state structs |
| 219 | |
| 220 | struct xhci_ring { |
| 221 | struct xhci_trb ring[XHCI_RING_ITEMS]; |
| 222 | struct xhci_trb evt; |
| 223 | u32 eidx; |
| 224 | u32 nidx; |
| 225 | u32 cs; |
| 226 | struct mutex_s lock; |
| 227 | }; |
| 228 | |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 229 | struct xhci_portmap { |
| 230 | u8 start; |
| 231 | u8 count; |
| 232 | }; |
| 233 | |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 234 | struct usb_xhci_s { |
| 235 | struct usb_s usb; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 236 | |
| 237 | /* devinfo */ |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 238 | u32 xcap; |
| 239 | u32 ports; |
| 240 | u32 slots; |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 241 | u8 context64; |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 242 | struct xhci_portmap usb2; |
| 243 | struct xhci_portmap usb3; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 244 | |
| 245 | /* xhci registers */ |
| 246 | struct xhci_caps *caps; |
| 247 | struct xhci_op *op; |
| 248 | struct xhci_pr *pr; |
| 249 | struct xhci_ir *ir; |
| 250 | struct xhci_db *db; |
| 251 | |
| 252 | /* xhci data structures */ |
| 253 | struct xhci_devlist *devs; |
| 254 | struct xhci_ring *cmds; |
| 255 | struct xhci_ring *evts; |
| 256 | struct xhci_er_seg *eseg; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 257 | }; |
| 258 | |
| 259 | struct xhci_pipe { |
| 260 | struct xhci_ring reqs; |
| 261 | |
| 262 | struct usb_pipe pipe; |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 263 | u32 slotid; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 264 | u32 epid; |
| 265 | void *buf; |
| 266 | int bufused; |
| 267 | }; |
| 268 | |
| 269 | // -------------------------------------------------------------- |
| 270 | // tables |
| 271 | |
| 272 | static const char *speed_name[16] = { |
| 273 | [ 0 ] = " - ", |
| 274 | [ 1 ] = "Full", |
| 275 | [ 2 ] = "Low", |
| 276 | [ 3 ] = "High", |
| 277 | [ 4 ] = "Super", |
| 278 | }; |
| 279 | |
| 280 | static const int speed_from_xhci[16] = { |
Paul Menzel | f08e847 | 2013-10-03 11:55:48 +0200 | [diff] [blame] | 281 | [ 0 ] = -1, |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 282 | [ 1 ] = USB_FULLSPEED, |
| 283 | [ 2 ] = USB_LOWSPEED, |
| 284 | [ 3 ] = USB_HIGHSPEED, |
| 285 | [ 4 ] = USB_SUPERSPEED, |
Paul Menzel | f08e847 | 2013-10-03 11:55:48 +0200 | [diff] [blame] | 286 | [ 5 ... 15 ] = -1, |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 287 | }; |
| 288 | |
| 289 | static const int speed_to_xhci[] = { |
| 290 | [ USB_FULLSPEED ] = 1, |
| 291 | [ USB_LOWSPEED ] = 2, |
| 292 | [ USB_HIGHSPEED ] = 3, |
| 293 | [ USB_SUPERSPEED ] = 4, |
| 294 | }; |
| 295 | |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 296 | static int wait_bit(u32 *reg, u32 mask, int value, u32 timeout) |
| 297 | { |
| 298 | u32 end = timer_calc(timeout); |
| 299 | |
| 300 | while ((readl(reg) & mask) != value) { |
| 301 | if (timer_check(end)) { |
| 302 | warn_timeout(); |
| 303 | return -1; |
| 304 | } |
| 305 | yield(); |
| 306 | } |
| 307 | return 0; |
| 308 | } |
| 309 | |
| 310 | |
| 311 | /**************************************************************** |
| 312 | * Root hub |
| 313 | ****************************************************************/ |
| 314 | |
Kevin O'Connor | 0f68130 | 2014-09-10 11:33:01 -0400 | [diff] [blame] | 315 | #define XHCI_TIME_POSTPOWER 20 |
| 316 | |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 317 | // Check if device attached to port |
| 318 | static void |
| 319 | xhci_print_port_state(int loglevel, const char *prefix, u32 port, u32 portsc) |
| 320 | { |
| 321 | u32 pls = xhci_get_field(portsc, XHCI_PORTSC_PLS); |
| 322 | u32 speed = xhci_get_field(portsc, XHCI_PORTSC_SPEED); |
| 323 | |
| 324 | dprintf(loglevel, "%s port #%d: 0x%08x,%s%s pls %d, speed %d [%s]\n", |
| 325 | prefix, port + 1, portsc, |
| 326 | (portsc & XHCI_PORTSC_PP) ? " powered," : "", |
| 327 | (portsc & XHCI_PORTSC_PED) ? " enabled," : "", |
| 328 | pls, speed, speed_name[speed]); |
| 329 | } |
| 330 | |
| 331 | static int |
| 332 | xhci_hub_detect(struct usbhub_s *hub, u32 port) |
| 333 | { |
| 334 | struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb); |
| 335 | u32 portsc = readl(&xhci->pr[port].portsc); |
Kevin O'Connor | 0f68130 | 2014-09-10 11:33:01 -0400 | [diff] [blame] | 336 | return (portsc & XHCI_PORTSC_CCS) ? 1 : 0; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | // Reset device on port |
| 340 | static int |
| 341 | xhci_hub_reset(struct usbhub_s *hub, u32 port) |
| 342 | { |
| 343 | struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb); |
| 344 | u32 portsc = readl(&xhci->pr[port].portsc); |
Kevin O'Connor | aa34e4e | 2015-11-10 08:50:52 -0500 | [diff] [blame] | 345 | if (!(portsc & XHCI_PORTSC_CCS)) |
| 346 | // Device no longer connected?! |
| 347 | return -1; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 348 | |
| 349 | switch (xhci_get_field(portsc, XHCI_PORTSC_PLS)) { |
| 350 | case PLS_U0: |
Kevin O'Connor | c01b41c | 2015-12-13 14:49:41 -0500 | [diff] [blame] | 351 | // A USB3 port - controller automatically performs reset |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 352 | break; |
| 353 | case PLS_POLLING: |
Kevin O'Connor | c01b41c | 2015-12-13 14:49:41 -0500 | [diff] [blame] | 354 | // A USB2 port - perform device reset |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 355 | xhci_print_port_state(3, __func__, port, portsc); |
Kevin O'Connor | aa34e4e | 2015-11-10 08:50:52 -0500 | [diff] [blame] | 356 | writel(&xhci->pr[port].portsc, portsc | XHCI_PORTSC_PR); |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 357 | break; |
| 358 | default: |
Kevin O'Connor | c01b41c | 2015-12-13 14:49:41 -0500 | [diff] [blame] | 359 | return -1; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 360 | } |
| 361 | |
Kevin O'Connor | c01b41c | 2015-12-13 14:49:41 -0500 | [diff] [blame] | 362 | // Wait for device to complete reset and be enabled |
| 363 | u32 end = timer_calc(100); |
| 364 | for (;;) { |
| 365 | portsc = readl(&xhci->pr[port].portsc); |
| 366 | if (!(portsc & XHCI_PORTSC_CCS)) |
| 367 | // Device disconnected during reset |
| 368 | return -1; |
| 369 | if (portsc & XHCI_PORTSC_PED) |
| 370 | // Reset complete |
| 371 | break; |
| 372 | if (timer_check(end)) { |
| 373 | warn_timeout(); |
| 374 | return -1; |
| 375 | } |
| 376 | yield(); |
| 377 | } |
| 378 | |
| 379 | int rc = speed_from_xhci[xhci_get_field(portsc, XHCI_PORTSC_SPEED)]; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 380 | xhci_print_port_state(1, "XHCI", port, portsc); |
| 381 | return rc; |
| 382 | } |
| 383 | |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 384 | static int |
| 385 | xhci_hub_portmap(struct usbhub_s *hub, u32 vport) |
| 386 | { |
| 387 | struct usb_xhci_s *xhci = container_of(hub->cntl, struct usb_xhci_s, usb); |
| 388 | u32 pport = vport + 1; |
| 389 | |
| 390 | if (vport + 1 >= xhci->usb3.start && |
| 391 | vport + 1 < xhci->usb3.start + xhci->usb3.count) |
| 392 | pport = vport + 2 - xhci->usb3.start; |
| 393 | |
| 394 | if (vport + 1 >= xhci->usb2.start && |
| 395 | vport + 1 < xhci->usb2.start + xhci->usb2.count) |
| 396 | pport = vport + 2 - xhci->usb2.start; |
| 397 | |
| 398 | return pport; |
| 399 | } |
| 400 | |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 401 | static void |
| 402 | xhci_hub_disconnect(struct usbhub_s *hub, u32 port) |
| 403 | { |
| 404 | // XXX - should turn the port power off. |
| 405 | } |
| 406 | |
| 407 | static struct usbhub_op_s xhci_hub_ops = { |
| 408 | .detect = xhci_hub_detect, |
| 409 | .reset = xhci_hub_reset, |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 410 | .portmap = xhci_hub_portmap, |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 411 | .disconnect = xhci_hub_disconnect, |
| 412 | }; |
| 413 | |
Kevin O'Connor | 7fb82b7 | 2014-09-10 09:10:42 -0400 | [diff] [blame] | 414 | // Find any devices connected to the root hub. |
| 415 | static int |
| 416 | xhci_check_ports(struct usb_xhci_s *xhci) |
| 417 | { |
Kevin O'Connor | 0f68130 | 2014-09-10 11:33:01 -0400 | [diff] [blame] | 418 | // Wait for port power to stabilize. |
| 419 | msleep(XHCI_TIME_POSTPOWER); |
Kevin O'Connor | 7fb82b7 | 2014-09-10 09:10:42 -0400 | [diff] [blame] | 420 | |
| 421 | struct usbhub_s hub; |
| 422 | memset(&hub, 0, sizeof(hub)); |
| 423 | hub.cntl = &xhci->usb; |
| 424 | hub.portcount = xhci->ports; |
| 425 | hub.op = &xhci_hub_ops; |
| 426 | usb_enumerate(&hub); |
| 427 | return hub.devcount; |
| 428 | } |
| 429 | |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 430 | |
| 431 | /**************************************************************** |
| 432 | * Setup |
| 433 | ****************************************************************/ |
| 434 | |
| 435 | static void |
Kevin O'Connor | 7fb82b7 | 2014-09-10 09:10:42 -0400 | [diff] [blame] | 436 | xhci_free_pipes(struct usb_xhci_s *xhci) |
| 437 | { |
| 438 | // XXX - should walk list of pipes and free unused pipes. |
| 439 | } |
| 440 | |
| 441 | static void |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 442 | configure_xhci(void *data) |
| 443 | { |
| 444 | struct usb_xhci_s *xhci = data; |
| 445 | u32 reg; |
| 446 | |
| 447 | xhci->devs = memalign_high(64, sizeof(*xhci->devs) * (xhci->slots + 1)); |
| 448 | xhci->eseg = memalign_high(64, sizeof(*xhci->eseg)); |
| 449 | xhci->cmds = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->cmds)); |
| 450 | xhci->evts = memalign_high(XHCI_RING_SIZE, sizeof(*xhci->evts)); |
| 451 | if (!xhci->devs || !xhci->cmds || !xhci->evts || !xhci->eseg) { |
| 452 | warn_noalloc(); |
| 453 | goto fail; |
| 454 | } |
| 455 | memset(xhci->devs, 0, sizeof(*xhci->devs) * (xhci->slots + 1)); |
| 456 | memset(xhci->cmds, 0, sizeof(*xhci->cmds)); |
| 457 | memset(xhci->evts, 0, sizeof(*xhci->evts)); |
| 458 | memset(xhci->eseg, 0, sizeof(*xhci->eseg)); |
| 459 | |
| 460 | reg = readl(&xhci->op->usbcmd); |
| 461 | if (reg & XHCI_CMD_RS) { |
| 462 | reg &= ~XHCI_CMD_RS; |
| 463 | writel(&xhci->op->usbcmd, reg); |
| 464 | if (wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32) != 0) |
| 465 | goto fail; |
| 466 | } |
| 467 | |
| 468 | dprintf(3, "%s: resetting\n", __func__); |
| 469 | writel(&xhci->op->usbcmd, XHCI_CMD_HCRST); |
| 470 | if (wait_bit(&xhci->op->usbcmd, XHCI_CMD_HCRST, 0, 100) != 0) |
| 471 | goto fail; |
| 472 | if (wait_bit(&xhci->op->usbsts, XHCI_STS_CNR, 0, 100) != 0) |
| 473 | goto fail; |
| 474 | |
| 475 | writel(&xhci->op->config, xhci->slots); |
| 476 | writel(&xhci->op->dcbaap_low, (u32)xhci->devs); |
| 477 | writel(&xhci->op->dcbaap_high, 0); |
| 478 | writel(&xhci->op->crcr_low, (u32)xhci->cmds | 1); |
| 479 | writel(&xhci->op->crcr_high, 0); |
| 480 | xhci->cmds->cs = 1; |
| 481 | |
| 482 | xhci->eseg->ptr_low = (u32)xhci->evts; |
| 483 | xhci->eseg->ptr_high = 0; |
| 484 | xhci->eseg->size = XHCI_RING_ITEMS; |
| 485 | writel(&xhci->ir->erstsz, 1); |
| 486 | writel(&xhci->ir->erdp_low, (u32)xhci->evts); |
| 487 | writel(&xhci->ir->erdp_high, 0); |
| 488 | writel(&xhci->ir->erstba_low, (u32)xhci->eseg); |
| 489 | writel(&xhci->ir->erstba_high, 0); |
| 490 | xhci->evts->cs = 1; |
| 491 | |
| 492 | reg = readl(&xhci->caps->hcsparams2); |
Julius Werner | fd318e4 | 2015-08-07 20:07:12 -0700 | [diff] [blame] | 493 | u32 spb = (reg >> 21 & 0x1f) << 5 | reg >> 27; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 494 | if (spb) { |
| 495 | dprintf(3, "%s: setup %d scratch pad buffers\n", __func__, spb); |
| 496 | u64 *spba = memalign_high(64, sizeof(*spba) * spb); |
| 497 | void *pad = memalign_high(PAGE_SIZE, PAGE_SIZE * spb); |
| 498 | if (!spba || !pad) { |
| 499 | warn_noalloc(); |
| 500 | free(spba); |
| 501 | free(pad); |
| 502 | goto fail; |
| 503 | } |
| 504 | int i; |
| 505 | for (i = 0; i < spb; i++) |
| 506 | spba[i] = (u32)pad + (i * PAGE_SIZE); |
| 507 | xhci->devs[0].ptr_low = (u32)spba; |
| 508 | xhci->devs[0].ptr_high = 0; |
| 509 | } |
| 510 | |
| 511 | reg = readl(&xhci->op->usbcmd); |
| 512 | reg |= XHCI_CMD_RS; |
| 513 | writel(&xhci->op->usbcmd, reg); |
| 514 | |
Kevin O'Connor | 7fb82b7 | 2014-09-10 09:10:42 -0400 | [diff] [blame] | 515 | // Find devices |
| 516 | int count = xhci_check_ports(xhci); |
| 517 | xhci_free_pipes(xhci); |
| 518 | if (count) |
| 519 | // Success |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 520 | return; |
| 521 | |
| 522 | // No devices found - shutdown and free controller. |
| 523 | dprintf(1, "XHCI no devices found\n"); |
| 524 | reg = readl(&xhci->op->usbcmd); |
| 525 | reg &= ~XHCI_CMD_RS; |
| 526 | writel(&xhci->op->usbcmd, reg); |
| 527 | wait_bit(&xhci->op->usbsts, XHCI_STS_HCH, XHCI_STS_HCH, 32); |
| 528 | |
| 529 | fail: |
| 530 | free(xhci->eseg); |
| 531 | free(xhci->evts); |
| 532 | free(xhci->cmds); |
| 533 | free(xhci->devs); |
| 534 | free(xhci); |
| 535 | } |
| 536 | |
| 537 | static void |
| 538 | xhci_controller_setup(struct pci_device *pci) |
| 539 | { |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 540 | void *baseaddr = pci_enable_membar(pci, PCI_BASE_ADDRESS_0); |
| 541 | if (!baseaddr) |
| 542 | return; |
| 543 | |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 544 | struct usb_xhci_s *xhci = malloc_high(sizeof(*xhci)); |
| 545 | if (!xhci) { |
| 546 | warn_noalloc(); |
| 547 | return; |
| 548 | } |
| 549 | memset(xhci, 0, sizeof(*xhci)); |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 550 | xhci->caps = baseaddr; |
| 551 | xhci->op = baseaddr + readb(&xhci->caps->caplength); |
| 552 | xhci->pr = baseaddr + readb(&xhci->caps->caplength) + 0x400; |
| 553 | xhci->db = baseaddr + readl(&xhci->caps->dboff); |
| 554 | xhci->ir = baseaddr + readl(&xhci->caps->rtsoff) + 0x20; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 555 | |
| 556 | u32 hcs1 = readl(&xhci->caps->hcsparams1); |
| 557 | u32 hcc = readl(&xhci->caps->hccparams); |
| 558 | xhci->ports = (hcs1 >> 24) & 0xff; |
| 559 | xhci->slots = hcs1 & 0xff; |
| 560 | xhci->xcap = ((hcc >> 16) & 0xffff) << 2; |
| 561 | xhci->context64 = (hcc & 0x04) ? 1 : 0; |
| 562 | |
| 563 | xhci->usb.pci = pci; |
| 564 | xhci->usb.type = USB_TYPE_XHCI; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 565 | |
Kevin O'Connor | 7b67300 | 2016-02-03 03:03:15 -0500 | [diff] [blame] | 566 | dprintf(1, "XHCI init on dev %pP: regs @ %p, %d ports, %d slots" |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 567 | ", %d byte contexts\n" |
Kevin O'Connor | 7b67300 | 2016-02-03 03:03:15 -0500 | [diff] [blame] | 568 | , pci, xhci->caps, xhci->ports, xhci->slots |
| 569 | , xhci->context64 ? 64 : 32); |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 570 | |
| 571 | if (xhci->xcap) { |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 572 | u32 off; |
| 573 | void *addr = baseaddr + xhci->xcap; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 574 | do { |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 575 | struct xhci_xcap *xcap = addr; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 576 | u32 ports, name, cap = readl(&xcap->cap); |
| 577 | switch (cap & 0xff) { |
| 578 | case 0x02: |
| 579 | name = readl(&xcap->data[0]); |
| 580 | ports = readl(&xcap->data[1]); |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 581 | u8 major = (cap >> 24) & 0xff; |
| 582 | u8 minor = (cap >> 16) & 0xff; |
| 583 | u8 count = (ports >> 8) & 0xff; |
| 584 | u8 start = (ports >> 0) & 0xff; |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 585 | dprintf(1, "XHCI protocol %c%c%c%c %x.%02x" |
| 586 | ", %d ports (offset %d), def %x\n" |
| 587 | , (name >> 0) & 0xff |
| 588 | , (name >> 8) & 0xff |
| 589 | , (name >> 16) & 0xff |
| 590 | , (name >> 24) & 0xff |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 591 | , major, minor |
| 592 | , count, start |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 593 | , ports >> 16); |
Gerd Hoffmann | b404a5f | 2017-07-18 13:15:42 +0200 | [diff] [blame] | 594 | if (name == 0x20425355 /* "USB " */) { |
| 595 | if (major == 2) { |
| 596 | xhci->usb2.start = start; |
| 597 | xhci->usb2.count = count; |
| 598 | } |
| 599 | if (major == 3) { |
| 600 | xhci->usb3.start = start; |
| 601 | xhci->usb3.count = count; |
| 602 | } |
| 603 | } |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 604 | break; |
| 605 | default: |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 606 | dprintf(1, "XHCI extcap 0x%x @ %p\n", cap & 0xff, addr); |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 607 | break; |
| 608 | } |
| 609 | off = (cap >> 8) & 0xff; |
| 610 | addr += off << 2; |
| 611 | } while (off > 0); |
| 612 | } |
| 613 | |
| 614 | u32 pagesize = readl(&xhci->op->pagesize); |
| 615 | if (PAGE_SIZE != (pagesize<<12)) { |
| 616 | dprintf(1, "XHCI driver does not support page size code %d\n" |
| 617 | , pagesize<<12); |
| 618 | free(xhci); |
| 619 | return; |
| 620 | } |
| 621 | |
Kevin O'Connor | c53953a | 2016-02-02 22:33:17 -0500 | [diff] [blame] | 622 | pci_enable_busmaster(pci); |
Kevin O'Connor | a76a4e1 | 2014-09-10 08:51:50 -0400 | [diff] [blame] | 623 | |
| 624 | run_thread(configure_xhci, xhci); |
| 625 | } |
| 626 | |
| 627 | void |
| 628 | xhci_setup(void) |
| 629 | { |
| 630 | if (! CONFIG_USB_XHCI) |
| 631 | return; |
| 632 | struct pci_device *pci; |
| 633 | foreachpci(pci) { |
| 634 | if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_XHCI) |
| 635 | xhci_controller_setup(pci); |
| 636 | } |
| 637 | } |
| 638 | |
| 639 | |
| 640 | /**************************************************************** |
| 641 | * End point communication |
| 642 | ****************************************************************/ |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 643 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 644 | // Signal the hardware to process events on a TRB ring |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 645 | static void xhci_doorbell(struct usb_xhci_s *xhci, u32 slotid, u32 value) |
| 646 | { |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 647 | dprintf(5, "%s: slotid %d, epid %d\n", __func__, slotid, value); |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 648 | struct xhci_db *db = xhci->db; |
Kevin O'Connor | de30dad | 2013-12-30 22:09:04 -0500 | [diff] [blame] | 649 | void *addr = &db[slotid].doorbell; |
| 650 | writel(addr, value); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 651 | } |
| 652 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 653 | // Dequeue events on the XHCI command ring generated by the hardware |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 654 | static void xhci_process_events(struct usb_xhci_s *xhci) |
| 655 | { |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 656 | struct xhci_ring *evts = xhci->evts; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 657 | |
| 658 | for (;;) { |
| 659 | /* check for event */ |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 660 | u32 nidx = evts->nidx; |
| 661 | u32 cs = evts->cs; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 662 | struct xhci_trb *etrb = evts->ring + nidx; |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 663 | u32 control = etrb->control; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 664 | if ((control & TRB_C) != (cs ? 1 : 0)) |
| 665 | return; |
| 666 | |
| 667 | /* process event */ |
| 668 | u32 evt_type = TRB_TYPE(control); |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 669 | u32 evt_cc = (etrb->status >> 24) & 0xff; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 670 | switch (evt_type) { |
| 671 | case ER_TRANSFER: |
| 672 | case ER_COMMAND_COMPLETE: |
| 673 | { |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 674 | struct xhci_trb *rtrb = (void*)etrb->ptr_low; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 675 | struct xhci_ring *ring = XHCI_RING(rtrb); |
| 676 | struct xhci_trb *evt = &ring->evt; |
| 677 | u32 eidx = rtrb - ring->ring + 1; |
| 678 | dprintf(5, "%s: ring %p [trb %p, evt %p, type %d, eidx %d, cc %d]\n", |
| 679 | __func__, ring, rtrb, evt, evt_type, eidx, evt_cc); |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 680 | memcpy(evt, etrb, sizeof(*etrb)); |
| 681 | ring->eidx = eidx; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 682 | break; |
| 683 | } |
| 684 | case ER_PORT_STATUS_CHANGE: |
| 685 | { |
Kevin O'Connor | 49fb034 | 2015-12-18 12:56:33 -0500 | [diff] [blame] | 686 | u32 port = ((etrb->ptr_low >> 24) & 0xff) - 1; |
| 687 | // Read status, and clear port status change bits |
| 688 | u32 portsc = readl(&xhci->pr[port].portsc); |
| 689 | u32 pclear = (((portsc & ~(XHCI_PORTSC_PED|XHCI_PORTSC_PR)) |
| 690 | & ~(XHCI_PORTSC_PLS_MASK<<XHCI_PORTSC_PLS_SHIFT)) |
| 691 | | (1<<XHCI_PORTSC_PLS_SHIFT)); |
| 692 | writel(&xhci->pr[port].portsc, pclear); |
| 693 | |
| 694 | xhci_print_port_state(3, __func__, port, portsc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 695 | break; |
| 696 | } |
| 697 | default: |
| 698 | dprintf(1, "%s: unknown event, type %d, cc %d\n", |
| 699 | __func__, evt_type, evt_cc); |
| 700 | break; |
| 701 | } |
| 702 | |
| 703 | /* move ring index, notify xhci */ |
| 704 | nidx++; |
| 705 | if (nidx == XHCI_RING_ITEMS) { |
| 706 | nidx = 0; |
| 707 | cs = cs ? 0 : 1; |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 708 | evts->cs = cs; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 709 | } |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 710 | evts->nidx = nidx; |
| 711 | struct xhci_ir *ir = xhci->ir; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 712 | u32 erdp = (u32)(evts->ring + nidx); |
Kevin O'Connor | de30dad | 2013-12-30 22:09:04 -0500 | [diff] [blame] | 713 | writel(&ir->erdp_low, erdp); |
| 714 | writel(&ir->erdp_high, 0); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 715 | } |
| 716 | } |
| 717 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 718 | // Check if a ring has any pending TRBs |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 719 | static int xhci_ring_busy(struct xhci_ring *ring) |
| 720 | { |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 721 | u32 eidx = ring->eidx; |
| 722 | u32 nidx = ring->nidx; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 723 | return (eidx != nidx); |
| 724 | } |
| 725 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 726 | // Wait for a ring to empty (all TRBs processed by hardware) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 727 | static int xhci_event_wait(struct usb_xhci_s *xhci, |
| 728 | struct xhci_ring *ring, |
| 729 | u32 timeout) |
| 730 | { |
| 731 | u32 end = timer_calc(timeout); |
| 732 | |
| 733 | for (;;) { |
| 734 | xhci_process_events(xhci); |
| 735 | if (!xhci_ring_busy(ring)) { |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 736 | u32 status = ring->evt.status; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 737 | return (status >> 24) & 0xff; |
| 738 | } |
| 739 | if (timer_check(end)) { |
| 740 | warn_timeout(); |
| 741 | return -1; |
| 742 | } |
| 743 | yield(); |
| 744 | } |
| 745 | } |
| 746 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 747 | // Add a TRB to the given ring |
| 748 | static void xhci_trb_fill(struct xhci_ring *ring |
| 749 | , void *data, u32 xferlen, u32 flags) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 750 | { |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 751 | struct xhci_trb *dst = &ring->ring[ring->nidx]; |
| 752 | if (flags & TRB_TR_IDT) { |
| 753 | memcpy(&dst->ptr_low, data, xferlen); |
| 754 | } else { |
| 755 | dst->ptr_low = (u32)data; |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 756 | dst->ptr_high = 0; |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 757 | } |
| 758 | dst->status = xferlen; |
| 759 | dst->control = flags | (ring->cs ? TRB_C : 0); |
| 760 | } |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 761 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 762 | // Queue a TRB onto a ring, wrapping ring as needed |
| 763 | static void xhci_trb_queue(struct xhci_ring *ring, |
| 764 | void *data, u32 xferlen, u32 flags) |
| 765 | { |
| 766 | if (ring->nidx >= ARRAY_SIZE(ring->ring) - 1) { |
| 767 | xhci_trb_fill(ring, ring->ring, 0, (TR_LINK << 10) | TRB_LK_TC); |
| 768 | ring->nidx = 0; |
| 769 | ring->cs ^= 1; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 770 | dprintf(5, "%s: ring %p [linked]\n", __func__, ring); |
| 771 | } |
| 772 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 773 | xhci_trb_fill(ring, data, xferlen, flags); |
| 774 | ring->nidx++; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 775 | dprintf(5, "%s: ring %p [nidx %d, len %d]\n", |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 776 | __func__, ring, ring->nidx, xferlen); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 777 | } |
| 778 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 779 | // Submit a command to the xhci controller ring |
| 780 | static int xhci_cmd_submit(struct usb_xhci_s *xhci, struct xhci_inctx *inctx |
| 781 | , u32 flags) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 782 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 783 | mutex_lock(&xhci->cmds->lock); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 784 | xhci_trb_queue(xhci->cmds, inctx, 0, flags); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 785 | xhci_doorbell(xhci, 0, 0); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 786 | int rc = xhci_event_wait(xhci, xhci->cmds, 1000); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 787 | mutex_unlock(&xhci->cmds->lock); |
| 788 | return rc; |
| 789 | } |
| 790 | |
| 791 | static int xhci_cmd_enable_slot(struct usb_xhci_s *xhci) |
| 792 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 793 | dprintf(3, "%s:\n", __func__); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 794 | int cc = xhci_cmd_submit(xhci, NULL, CR_ENABLE_SLOT << 10); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 795 | if (cc != CC_SUCCESS) |
| 796 | return -1; |
| 797 | return (xhci->cmds->evt.control >> 24) & 0xff; |
| 798 | } |
| 799 | |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 800 | static int xhci_cmd_disable_slot(struct usb_xhci_s *xhci, u32 slotid) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 801 | { |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 802 | dprintf(3, "%s: slotid %d\n", __func__, slotid); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 803 | return xhci_cmd_submit(xhci, NULL, (CR_DISABLE_SLOT << 10) | (slotid << 24)); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 804 | } |
| 805 | |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 806 | static int xhci_cmd_address_device(struct usb_xhci_s *xhci, u32 slotid |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 807 | , struct xhci_inctx *inctx) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 808 | { |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 809 | dprintf(3, "%s: slotid %d\n", __func__, slotid); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 810 | return xhci_cmd_submit(xhci, inctx |
| 811 | , (CR_ADDRESS_DEVICE << 10) | (slotid << 24)); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 812 | } |
| 813 | |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 814 | static int xhci_cmd_configure_endpoint(struct usb_xhci_s *xhci, u32 slotid |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 815 | , struct xhci_inctx *inctx) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 816 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 817 | dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__, |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 818 | slotid, inctx->add, inctx->del); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 819 | return xhci_cmd_submit(xhci, inctx |
| 820 | , (CR_CONFIGURE_ENDPOINT << 10) | (slotid << 24)); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 821 | } |
| 822 | |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 823 | static int xhci_cmd_evaluate_context(struct usb_xhci_s *xhci, u32 slotid |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 824 | , struct xhci_inctx *inctx) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 825 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 826 | dprintf(3, "%s: slotid %d, add 0x%x, del 0x%x\n", __func__, |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 827 | slotid, inctx->add, inctx->del); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 828 | return xhci_cmd_submit(xhci, inctx |
| 829 | , (CR_EVALUATE_CONTEXT << 10) | (slotid << 24)); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 830 | } |
| 831 | |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 832 | static struct xhci_inctx * |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 833 | xhci_alloc_inctx(struct usbdevice_s *usbdev, int maxepid) |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 834 | { |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 835 | struct usb_xhci_s *xhci = container_of( |
| 836 | usbdev->hub->cntl, struct usb_xhci_s, usb); |
| 837 | int size = (sizeof(struct xhci_inctx) * 33) << xhci->context64; |
| 838 | struct xhci_inctx *in = memalign_tmphigh(2048 << xhci->context64, size); |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 839 | if (!in) { |
| 840 | warn_noalloc(); |
| 841 | return NULL; |
| 842 | } |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 843 | memset(in, 0, size); |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 844 | |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 845 | struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64]; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 846 | slot->ctx[0] |= maxepid << 27; // context entries |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 847 | slot->ctx[0] |= speed_to_xhci[usbdev->speed] << 20; |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 848 | |
| 849 | // Set high-speed hub flags. |
| 850 | struct usbdevice_s *hubdev = usbdev->hub->usbdev; |
| 851 | if (hubdev) { |
| 852 | if (usbdev->speed == USB_LOWSPEED || usbdev->speed == USB_FULLSPEED) { |
| 853 | struct xhci_pipe *hpipe = container_of( |
| 854 | hubdev->defpipe, struct xhci_pipe, pipe); |
| 855 | if (hubdev->speed == USB_HIGHSPEED) { |
| 856 | slot->ctx[2] |= hpipe->slotid; |
| 857 | slot->ctx[2] |= (usbdev->port+1) << 8; |
| 858 | } else { |
| 859 | struct xhci_slotctx *hslot = (void*)xhci->devs[hpipe->slotid].ptr_low; |
| 860 | slot->ctx[2] = hslot->ctx[2]; |
| 861 | } |
| 862 | } |
| 863 | u32 route = 0; |
| 864 | while (usbdev->hub->usbdev) { |
| 865 | route <<= 4; |
| 866 | route |= (usbdev->port+1) & 0xf; |
| 867 | usbdev = usbdev->hub->usbdev; |
| 868 | } |
| 869 | slot->ctx[0] |= route; |
| 870 | } |
| 871 | |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 872 | slot->ctx[1] |= (usbdev->port+1) << 16; |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 873 | |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 874 | return in; |
| 875 | } |
| 876 | |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 877 | static int xhci_config_hub(struct usbhub_s *hub) |
| 878 | { |
| 879 | struct usb_xhci_s *xhci = container_of( |
| 880 | hub->cntl, struct usb_xhci_s, usb); |
| 881 | struct xhci_pipe *pipe = container_of( |
| 882 | hub->usbdev->defpipe, struct xhci_pipe, pipe); |
| 883 | struct xhci_slotctx *hdslot = (void*)xhci->devs[pipe->slotid].ptr_low; |
| 884 | if ((hdslot->ctx[3] >> 27) == 3) |
| 885 | // Already configured |
| 886 | return 0; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 887 | struct xhci_inctx *in = xhci_alloc_inctx(hub->usbdev, 1); |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 888 | if (!in) |
| 889 | return -1; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 890 | in->add = 0x01; |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 891 | struct xhci_slotctx *slot = (void*)&in[1 << xhci->context64]; |
| 892 | slot->ctx[0] |= 1 << 26; |
| 893 | slot->ctx[1] |= hub->portcount << 24; |
| 894 | |
| 895 | int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in); |
| 896 | free(in); |
| 897 | if (cc != CC_SUCCESS) { |
| 898 | dprintf(1, "%s: configure hub: failed (cc %d)\n", __func__, cc); |
| 899 | return -1; |
| 900 | } |
| 901 | return 0; |
| 902 | } |
| 903 | |
Kevin O'Connor | c427def | 2014-10-16 13:23:08 -0400 | [diff] [blame] | 904 | static struct usb_pipe * |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 905 | xhci_alloc_pipe(struct usbdevice_s *usbdev |
| 906 | , struct usb_endpoint_descriptor *epdesc) |
| 907 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 908 | u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; |
| 909 | struct usb_xhci_s *xhci = container_of( |
| 910 | usbdev->hub->cntl, struct usb_xhci_s, usb); |
| 911 | struct xhci_pipe *pipe; |
| 912 | u32 epid; |
| 913 | |
| 914 | if (epdesc->bEndpointAddress == 0) { |
| 915 | epid = 1; |
| 916 | } else { |
| 917 | epid = (epdesc->bEndpointAddress & 0x0f) * 2; |
| 918 | epid += (epdesc->bEndpointAddress & USB_DIR_IN) ? 1 : 0; |
| 919 | } |
| 920 | |
| 921 | if (eptype == USB_ENDPOINT_XFER_CONTROL) |
| 922 | pipe = memalign_high(XHCI_RING_SIZE, sizeof(*pipe)); |
| 923 | else |
| 924 | pipe = memalign_low(XHCI_RING_SIZE, sizeof(*pipe)); |
| 925 | if (!pipe) { |
| 926 | warn_noalloc(); |
| 927 | return NULL; |
| 928 | } |
| 929 | memset(pipe, 0, sizeof(*pipe)); |
| 930 | |
| 931 | usb_desc2pipe(&pipe->pipe, usbdev, epdesc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 932 | pipe->epid = epid; |
| 933 | pipe->reqs.cs = 1; |
Kevin O'Connor | 3abdc7c | 2015-06-30 11:10:41 -0400 | [diff] [blame] | 934 | if (eptype == USB_ENDPOINT_XFER_INT) { |
Kevin O'Connor | c46f5a9 | 2014-09-10 09:31:43 -0400 | [diff] [blame] | 935 | pipe->buf = malloc_high(pipe->pipe.maxpacket); |
Kevin O'Connor | 3abdc7c | 2015-06-30 11:10:41 -0400 | [diff] [blame] | 936 | if (!pipe->buf) { |
| 937 | warn_noalloc(); |
| 938 | free(pipe); |
| 939 | return NULL; |
| 940 | } |
| 941 | } |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 942 | |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 943 | // Allocate input context and initialize endpoint info. |
| 944 | struct xhci_inctx *in = xhci_alloc_inctx(usbdev, epid); |
| 945 | if (!in) |
| 946 | goto fail; |
| 947 | in->add = 0x01 | (1 << epid); |
| 948 | struct xhci_epctx *ep = (void*)&in[(pipe->epid+1) << xhci->context64]; |
| 949 | if (eptype == USB_ENDPOINT_XFER_INT) |
Kevin O'Connor | 98cdad3 | 2014-10-16 12:05:09 -0400 | [diff] [blame] | 950 | ep->ctx[0] = (usb_get_period(usbdev, epdesc) + 3) << 16; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 951 | ep->ctx[1] |= eptype << 3; |
| 952 | if (epdesc->bEndpointAddress & USB_DIR_IN |
| 953 | || eptype == USB_ENDPOINT_XFER_CONTROL) |
| 954 | ep->ctx[1] |= 1 << 5; |
| 955 | ep->ctx[1] |= pipe->pipe.maxpacket << 16; |
| 956 | ep->deq_low = (u32)&pipe->reqs.ring[0]; |
| 957 | ep->deq_low |= 1; // dcs |
| 958 | ep->length = pipe->pipe.maxpacket; |
| 959 | |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 960 | dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__, |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 961 | usbdev, &pipe->reqs, pipe->slotid, pipe->epid); |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 962 | if (pipe->epid == 1) { |
Kevin O'Connor | 1540f92 | 2013-12-29 20:18:37 -0500 | [diff] [blame] | 963 | if (usbdev->hub->usbdev) { |
| 964 | // Make sure parent hub is configured. |
| 965 | int ret = xhci_config_hub(usbdev->hub); |
| 966 | if (ret) |
| 967 | goto fail; |
| 968 | } |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 969 | // Enable slot. |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 970 | u32 size = (sizeof(struct xhci_slotctx) * 32) << xhci->context64; |
| 971 | struct xhci_slotctx *dev = memalign_high(1024 << xhci->context64, size); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 972 | if (!dev) { |
| 973 | warn_noalloc(); |
| 974 | goto fail; |
| 975 | } |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 976 | int slotid = xhci_cmd_enable_slot(xhci); |
| 977 | if (slotid < 0) { |
| 978 | dprintf(1, "%s: enable slot: failed\n", __func__); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 979 | free(dev); |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 980 | goto fail; |
| 981 | } |
| 982 | dprintf(3, "%s: enable slot: got slotid %d\n", __func__, slotid); |
Kevin O'Connor | 20aeae7 | 2013-12-27 21:46:35 -0500 | [diff] [blame] | 983 | memset(dev, 0, size); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 984 | xhci->devs[slotid].ptr_low = (u32)dev; |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 985 | xhci->devs[slotid].ptr_high = 0; |
| 986 | |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 987 | // Send set_address command. |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 988 | int cc = xhci_cmd_address_device(xhci, slotid, in); |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 989 | if (cc != CC_SUCCESS) { |
| 990 | dprintf(1, "%s: address device: failed (cc %d)\n", __func__, cc); |
Kevin O'Connor | 636cbb4 | 2015-12-20 15:50:10 -0500 | [diff] [blame] | 991 | cc = xhci_cmd_disable_slot(xhci, slotid); |
| 992 | if (cc != CC_SUCCESS) { |
| 993 | dprintf(1, "%s: disable failed (cc %d)\n", __func__, cc); |
| 994 | goto fail; |
| 995 | } |
| 996 | xhci->devs[slotid].ptr_low = 0; |
| 997 | free(dev); |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 998 | goto fail; |
| 999 | } |
Kevin O'Connor | 3c577a7 | 2016-01-05 13:41:09 -0500 | [diff] [blame] | 1000 | pipe->slotid = slotid; |
Kevin O'Connor | 4ea2fa9 | 2013-12-27 19:25:46 -0500 | [diff] [blame] | 1001 | } else { |
Kevin O'Connor | 3c577a7 | 2016-01-05 13:41:09 -0500 | [diff] [blame] | 1002 | struct xhci_pipe *defpipe = container_of( |
| 1003 | usbdev->defpipe, struct xhci_pipe, pipe); |
| 1004 | pipe->slotid = defpipe->slotid; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 1005 | // Send configure command. |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 1006 | int cc = xhci_cmd_configure_endpoint(xhci, pipe->slotid, in); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1007 | if (cc != CC_SUCCESS) { |
| 1008 | dprintf(1, "%s: configure endpoint: failed (cc %d)\n", __func__, cc); |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 1009 | goto fail; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1010 | } |
| 1011 | } |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 1012 | free(in); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1013 | return &pipe->pipe; |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 1014 | |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 1015 | fail: |
Kevin O'Connor | 3abdc7c | 2015-06-30 11:10:41 -0400 | [diff] [blame] | 1016 | free(pipe->buf); |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 1017 | free(pipe); |
Kevin O'Connor | 5c6fa33 | 2014-01-27 11:49:51 -0500 | [diff] [blame] | 1018 | free(in); |
Kevin O'Connor | d477d55 | 2013-12-27 18:09:16 -0500 | [diff] [blame] | 1019 | return NULL; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1020 | } |
| 1021 | |
| 1022 | struct usb_pipe * |
Kevin O'Connor | c427def | 2014-10-16 13:23:08 -0400 | [diff] [blame] | 1023 | xhci_realloc_pipe(struct usbdevice_s *usbdev, struct usb_pipe *upipe |
| 1024 | , struct usb_endpoint_descriptor *epdesc) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1025 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1026 | if (!CONFIG_USB_XHCI) |
| 1027 | return NULL; |
Kevin O'Connor | c427def | 2014-10-16 13:23:08 -0400 | [diff] [blame] | 1028 | if (!epdesc) { |
| 1029 | usb_add_freelist(upipe); |
| 1030 | return NULL; |
| 1031 | } |
| 1032 | if (!upipe) |
| 1033 | return xhci_alloc_pipe(usbdev, epdesc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1034 | u8 eptype = epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; |
Kevin O'Connor | ab8ef4a | 2014-09-09 19:31:45 -0400 | [diff] [blame] | 1035 | int oldmaxpacket = upipe->maxpacket; |
| 1036 | usb_desc2pipe(upipe, usbdev, epdesc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1037 | struct xhci_pipe *pipe = container_of(upipe, struct xhci_pipe, pipe); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 1038 | struct usb_xhci_s *xhci = container_of( |
| 1039 | pipe->pipe.cntl, struct usb_xhci_s, usb); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1040 | dprintf(3, "%s: usbdev %p, ring %p, slotid %d, epid %d\n", __func__, |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 1041 | usbdev, &pipe->reqs, pipe->slotid, pipe->epid); |
Kevin O'Connor | ab8ef4a | 2014-09-09 19:31:45 -0400 | [diff] [blame] | 1042 | if (eptype != USB_ENDPOINT_XFER_CONTROL || upipe->maxpacket == oldmaxpacket) |
| 1043 | return upipe; |
| 1044 | |
| 1045 | // maxpacket has changed on control endpoint - update controller. |
| 1046 | dprintf(1, "%s: reconf ctl endpoint pkt size: %d -> %d\n", |
| 1047 | __func__, oldmaxpacket, pipe->pipe.maxpacket); |
| 1048 | struct xhci_inctx *in = xhci_alloc_inctx(usbdev, 1); |
| 1049 | if (!in) |
| 1050 | return upipe; |
| 1051 | in->add = (1 << 1); |
| 1052 | struct xhci_epctx *ep = (void*)&in[2 << xhci->context64]; |
| 1053 | ep->ctx[1] |= (pipe->pipe.maxpacket << 16); |
| 1054 | int cc = xhci_cmd_evaluate_context(xhci, pipe->slotid, in); |
| 1055 | if (cc != CC_SUCCESS) { |
| 1056 | dprintf(1, "%s: reconf ctl endpoint: failed (cc %d)\n", |
| 1057 | __func__, cc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1058 | } |
Kevin O'Connor | ab8ef4a | 2014-09-09 19:31:45 -0400 | [diff] [blame] | 1059 | free(in); |
| 1060 | |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1061 | return upipe; |
| 1062 | } |
| 1063 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 1064 | // Submit a USB "setup" message request to the pipe's ring |
| 1065 | static void xhci_xfer_setup(struct xhci_pipe *pipe, int dir, void *cmd |
| 1066 | , void *data, int datalen) |
Kevin O'Connor | 2ba8907 | 2014-12-31 02:25:58 -0500 | [diff] [blame] | 1067 | { |
| 1068 | struct usb_xhci_s *xhci = container_of( |
| 1069 | pipe->pipe.cntl, struct usb_xhci_s, usb); |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 1070 | xhci_trb_queue(&pipe->reqs, cmd, USB_CONTROL_SETUP_SIZE |
| 1071 | , (TR_SETUP << 10) | TRB_TR_IDT |
| 1072 | | ((datalen ? (dir ? 3 : 2) : 0) << 16)); |
| 1073 | if (datalen) |
| 1074 | xhci_trb_queue(&pipe->reqs, data, datalen, (TR_DATA << 10) |
| 1075 | | ((dir ? 1 : 0) << 16)); |
| 1076 | xhci_trb_queue(&pipe->reqs, NULL, 0, (TR_STATUS << 10) | TRB_TR_IOC |
| 1077 | | ((dir ? 0 : 1) << 16)); |
| 1078 | xhci_doorbell(xhci, pipe->slotid, pipe->epid); |
Kevin O'Connor | 2ba8907 | 2014-12-31 02:25:58 -0500 | [diff] [blame] | 1079 | } |
| 1080 | |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 1081 | // Submit a USB transfer request to the pipe's ring |
Kevin O'Connor | 2ba8907 | 2014-12-31 02:25:58 -0500 | [diff] [blame] | 1082 | static void xhci_xfer_normal(struct xhci_pipe *pipe, |
| 1083 | void *data, int datalen) |
| 1084 | { |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 1085 | struct usb_xhci_s *xhci = container_of( |
| 1086 | pipe->pipe.cntl, struct usb_xhci_s, usb); |
| 1087 | xhci_trb_queue(&pipe->reqs, data, datalen, (TR_NORMAL << 10) | TRB_TR_IOC); |
| 1088 | xhci_doorbell(xhci, pipe->slotid, pipe->epid); |
Kevin O'Connor | 2ba8907 | 2014-12-31 02:25:58 -0500 | [diff] [blame] | 1089 | } |
| 1090 | |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1091 | int |
Kevin O'Connor | 2891a83 | 2014-12-31 17:41:14 -0500 | [diff] [blame] | 1092 | xhci_send_pipe(struct usb_pipe *p, int dir, const void *cmd |
Kevin O'Connor | b33e31d | 2014-12-31 02:07:37 -0500 | [diff] [blame] | 1093 | , void *data, int datalen) |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1094 | { |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1095 | if (!CONFIG_USB_XHCI) |
| 1096 | return -1; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1097 | struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 1098 | struct usb_xhci_s *xhci = container_of( |
| 1099 | pipe->pipe.cntl, struct usb_xhci_s, usb); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1100 | |
Kevin O'Connor | b33e31d | 2014-12-31 02:07:37 -0500 | [diff] [blame] | 1101 | if (cmd) { |
| 1102 | const struct usb_ctrlrequest *req = cmd; |
| 1103 | if (req->bRequest == USB_REQ_SET_ADDRESS) |
| 1104 | // Set address command sent during xhci_alloc_pipe. |
| 1105 | return 0; |
Kevin O'Connor | 4b48839 | 2017-10-03 10:45:24 -0400 | [diff] [blame^] | 1106 | xhci_xfer_setup(pipe, dir, (void*)req, data, datalen); |
Kevin O'Connor | b33e31d | 2014-12-31 02:07:37 -0500 | [diff] [blame] | 1107 | } else { |
| 1108 | xhci_xfer_normal(pipe, data, datalen); |
| 1109 | } |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1110 | |
Kevin O'Connor | 88fa227 | 2014-06-14 12:25:17 -0400 | [diff] [blame] | 1111 | int cc = xhci_event_wait(xhci, &pipe->reqs, usb_xfer_time(p, datalen)); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1112 | if (cc != CC_SUCCESS) { |
Kevin O'Connor | b33e31d | 2014-12-31 02:07:37 -0500 | [diff] [blame] | 1113 | dprintf(1, "%s: xfer failed (cc %d)\n", __func__, cc); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1114 | return -1; |
| 1115 | } |
| 1116 | |
| 1117 | return 0; |
| 1118 | } |
| 1119 | |
Kevin O'Connor | de30dad | 2013-12-30 22:09:04 -0500 | [diff] [blame] | 1120 | int VISIBLE32FLAT |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1121 | xhci_poll_intr(struct usb_pipe *p, void *data) |
| 1122 | { |
| 1123 | if (!CONFIG_USB_XHCI) |
| 1124 | return -1; |
| 1125 | |
| 1126 | struct xhci_pipe *pipe = container_of(p, struct xhci_pipe, pipe); |
Kevin O'Connor | 81ee3bb | 2013-12-27 21:09:53 -0500 | [diff] [blame] | 1127 | struct usb_xhci_s *xhci = container_of( |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 1128 | pipe->pipe.cntl, struct usb_xhci_s, usb); |
| 1129 | u32 len = pipe->pipe.maxpacket; |
| 1130 | void *buf = pipe->buf; |
| 1131 | int bufused = pipe->bufused; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1132 | |
| 1133 | if (!bufused) { |
| 1134 | xhci_xfer_normal(pipe, buf, len); |
| 1135 | bufused = 1; |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 1136 | pipe->bufused = bufused; |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1137 | return -1; |
| 1138 | } |
| 1139 | |
| 1140 | xhci_process_events(xhci); |
| 1141 | if (xhci_ring_busy(&pipe->reqs)) |
| 1142 | return -1; |
| 1143 | dprintf(5, "%s: st %x ct %x [ %p <= %p / %d ]\n", __func__, |
Kevin O'Connor | b203013 | 2014-09-10 08:31:28 -0400 | [diff] [blame] | 1144 | pipe->reqs.evt.status, |
| 1145 | pipe->reqs.evt.control, |
| 1146 | data, buf, len); |
| 1147 | memcpy(data, buf, len); |
Gerd Hoffmann | e144bb7 | 2013-06-03 16:30:18 +0200 | [diff] [blame] | 1148 | xhci_xfer_normal(pipe, buf, len); |
| 1149 | return 0; |
| 1150 | } |