1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 #ifndef __ASPEED_VHUB_H 3 #define __ASPEED_VHUB_H 4 5 /***************************** 6 * * 7 * VHUB register definitions * 8 * * 9 *****************************/ 10 11 #define AST_VHUB_CTRL 0x00 /* Root Function Control & Status Register */ 12 #define AST_VHUB_CONF 0x04 /* Root Configuration Setting Register */ 13 #define AST_VHUB_IER 0x08 /* Interrupt Ctrl Register */ 14 #define AST_VHUB_ISR 0x0C /* Interrupt Status Register */ 15 #define AST_VHUB_EP_ACK_IER 0x10 /* Programmable Endpoint Pool ACK Interrupt Enable Register */ 16 #define AST_VHUB_EP_NACK_IER 0x14 /* Programmable Endpoint Pool NACK Interrupt Enable Register */ 17 #define AST_VHUB_EP_ACK_ISR 0x18 /* Programmable Endpoint Pool ACK Interrupt Status Register */ 18 #define AST_VHUB_EP_NACK_ISR 0x1C /* Programmable Endpoint Pool NACK Interrupt Status Register */ 19 #define AST_VHUB_SW_RESET 0x20 /* Device Controller Soft Reset Enable Register */ 20 #define AST_VHUB_USBSTS 0x24 /* USB Status Register */ 21 #define AST_VHUB_EP_TOGGLE 0x28 /* Programmable Endpoint Pool Data Toggle Value Set */ 22 #define AST_VHUB_ISO_FAIL_ACC 0x2C /* Isochronous Transaction Fail Accumulator */ 23 #define AST_VHUB_EP0_CTRL 0x30 /* Endpoint 0 Contrl/Status Register */ 24 #define AST_VHUB_EP0_DATA 0x34 /* Base Address of Endpoint 0 In/OUT Data Buffer Register */ 25 #define AST_VHUB_EP1_CTRL 0x38 /* Endpoint 1 Contrl/Status Register */ 26 #define AST_VHUB_EP1_STS_CHG 0x3C /* Endpoint 1 Status Change Bitmap Data */ 27 #define AST_VHUB_SETUP0 0x80 /* Root Device Setup Data Buffer0 */ 28 #define AST_VHUB_SETUP1 0x84 /* Root Device Setup Data Buffer1 */ 29 30 /* Main control reg */ 31 #define VHUB_CTRL_PHY_CLK (1 << 31) 32 #define VHUB_CTRL_PHY_LOOP_TEST (1 << 25) 33 #define VHUB_CTRL_DN_PWN (1 << 24) 34 #define VHUB_CTRL_DP_PWN (1 << 23) 35 #define VHUB_CTRL_LONG_DESC (1 << 18) 36 #define VHUB_CTRL_ISO_RSP_CTRL (1 << 17) 37 #define VHUB_CTRL_SPLIT_IN (1 << 16) 38 #define VHUB_CTRL_LOOP_T_RESULT (1 << 15) 39 #define VHUB_CTRL_LOOP_T_STS (1 << 14) 40 #define VHUB_CTRL_PHY_BIST_RESULT (1 << 13) 41 #define VHUB_CTRL_PHY_BIST_CTRL (1 << 12) 42 #define VHUB_CTRL_PHY_RESET_DIS (1 << 11) 43 #define VHUB_CTRL_SET_TEST_MODE(x) ((x) << 8) 44 #define VHUB_CTRL_MANUAL_REMOTE_WAKEUP (1 << 4) 45 #define VHUB_CTRL_AUTO_REMOTE_WAKEUP (1 << 3) 46 #define VHUB_CTRL_CLK_STOP_SUSPEND (1 << 2) 47 #define VHUB_CTRL_FULL_SPEED_ONLY (1 << 1) 48 #define VHUB_CTRL_UPSTREAM_CONNECT (1 << 0) 49 50 /* IER & ISR */ 51 #define VHUB_IRQ_USB_CMD_DEADLOCK (1 << 18) 52 #define VHUB_IRQ_EP_POOL_NAK (1 << 17) 53 #define VHUB_IRQ_EP_POOL_ACK_STALL (1 << 16) 54 #define VHUB_IRQ_DEVICE5 (1 << 13) 55 #define VHUB_IRQ_DEVICE4 (1 << 12) 56 #define VHUB_IRQ_DEVICE3 (1 << 11) 57 #define VHUB_IRQ_DEVICE2 (1 << 10) 58 #define VHUB_IRQ_DEVICE1 (1 << 9) 59 #define VHUB_IRQ_BUS_RESUME (1 << 8) 60 #define VHUB_IRQ_BUS_SUSPEND (1 << 7) 61 #define VHUB_IRQ_BUS_RESET (1 << 6) 62 #define VHUB_IRQ_HUB_EP1_IN_DATA_ACK (1 << 5) 63 #define VHUB_IRQ_HUB_EP0_IN_DATA_NAK (1 << 4) 64 #define VHUB_IRQ_HUB_EP0_IN_ACK_STALL (1 << 3) 65 #define VHUB_IRQ_HUB_EP0_OUT_NAK (1 << 2) 66 #define VHUB_IRQ_HUB_EP0_OUT_ACK_STALL (1 << 1) 67 #define VHUB_IRQ_HUB_EP0_SETUP (1 << 0) 68 #define VHUB_IRQ_ACK_ALL 0x1ff 69 70 /* SW reset reg */ 71 #define VHUB_SW_RESET_EP_POOL (1 << 9) 72 #define VHUB_SW_RESET_DMA_CONTROLLER (1 << 8) 73 #define VHUB_SW_RESET_DEVICE5 (1 << 5) 74 #define VHUB_SW_RESET_DEVICE4 (1 << 4) 75 #define VHUB_SW_RESET_DEVICE3 (1 << 3) 76 #define VHUB_SW_RESET_DEVICE2 (1 << 2) 77 #define VHUB_SW_RESET_DEVICE1 (1 << 1) 78 #define VHUB_SW_RESET_ROOT_HUB (1 << 0) 79 #define VHUB_SW_RESET_ALL (VHUB_SW_RESET_EP_POOL | \ 80 VHUB_SW_RESET_DMA_CONTROLLER | \ 81 VHUB_SW_RESET_DEVICE5 | \ 82 VHUB_SW_RESET_DEVICE4 | \ 83 VHUB_SW_RESET_DEVICE3 | \ 84 VHUB_SW_RESET_DEVICE2 | \ 85 VHUB_SW_RESET_DEVICE1 | \ 86 VHUB_SW_RESET_ROOT_HUB) 87 /* EP ACK/NACK IRQ masks */ 88 #define VHUB_EP_IRQ(n) (1 << (n)) 89 #define VHUB_EP_IRQ_ALL 0x7fff /* 15 EPs */ 90 91 /* USB status reg */ 92 #define VHUB_USBSTS_HISPEED (1 << 27) 93 94 /* EP toggle */ 95 #define VHUB_EP_TOGGLE_VALUE (1 << 8) 96 #define VHUB_EP_TOGGLE_SET_EPNUM(x) ((x) & 0x1f) 97 98 /* HUB EP0 control */ 99 #define VHUB_EP0_CTRL_STALL (1 << 0) 100 #define VHUB_EP0_TX_BUFF_RDY (1 << 1) 101 #define VHUB_EP0_RX_BUFF_RDY (1 << 2) 102 #define VHUB_EP0_RX_LEN(x) (((x) >> 16) & 0x7f) 103 #define VHUB_EP0_SET_TX_LEN(x) (((x) & 0x7f) << 8) 104 105 /* HUB EP1 control */ 106 #define VHUB_EP1_CTRL_RESET_TOGGLE (1 << 2) 107 #define VHUB_EP1_CTRL_STALL (1 << 1) 108 #define VHUB_EP1_CTRL_ENABLE (1 << 0) 109 110 /*********************************** 111 * * 112 * per-device register definitions * 113 * * 114 ***********************************/ 115 #define AST_VHUB_DEV_EN_CTRL 0x00 116 #define AST_VHUB_DEV_ISR 0x04 117 #define AST_VHUB_DEV_EP0_CTRL 0x08 118 #define AST_VHUB_DEV_EP0_DATA 0x0c 119 120 /* Device enable control */ 121 #define VHUB_DEV_EN_SET_ADDR(x) ((x) << 8) 122 #define VHUB_DEV_EN_ADDR_MASK ((0xff) << 8) 123 #define VHUB_DEV_EN_EP0_NAK_IRQEN (1 << 6) 124 #define VHUB_DEV_EN_EP0_IN_ACK_IRQEN (1 << 5) 125 #define VHUB_DEV_EN_EP0_OUT_NAK_IRQEN (1 << 4) 126 #define VHUB_DEV_EN_EP0_OUT_ACK_IRQEN (1 << 3) 127 #define VHUB_DEV_EN_EP0_SETUP_IRQEN (1 << 2) 128 #define VHUB_DEV_EN_SPEED_SEL_HIGH (1 << 1) 129 #define VHUB_DEV_EN_ENABLE_PORT (1 << 0) 130 131 /* Interrupt status */ 132 #define VHUV_DEV_IRQ_EP0_IN_DATA_NACK (1 << 4) 133 #define VHUV_DEV_IRQ_EP0_IN_ACK_STALL (1 << 3) 134 #define VHUV_DEV_IRQ_EP0_OUT_DATA_NACK (1 << 2) 135 #define VHUV_DEV_IRQ_EP0_OUT_ACK_STALL (1 << 1) 136 #define VHUV_DEV_IRQ_EP0_SETUP (1 << 0) 137 138 /* Control bits. 139 * 140 * Note: The driver relies on the bulk of those bits 141 * matching corresponding vHub EP0 control bits 142 */ 143 #define VHUB_DEV_EP0_CTRL_STALL VHUB_EP0_CTRL_STALL 144 #define VHUB_DEV_EP0_TX_BUFF_RDY VHUB_EP0_TX_BUFF_RDY 145 #define VHUB_DEV_EP0_RX_BUFF_RDY VHUB_EP0_RX_BUFF_RDY 146 #define VHUB_DEV_EP0_RX_LEN(x) VHUB_EP0_RX_LEN(x) 147 #define VHUB_DEV_EP0_SET_TX_LEN(x) VHUB_EP0_SET_TX_LEN(x) 148 149 /************************************* 150 * * 151 * per-endpoint register definitions * 152 * * 153 *************************************/ 154 155 #define AST_VHUB_EP_CONFIG 0x00 156 #define AST_VHUB_EP_DMA_CTLSTAT 0x04 157 #define AST_VHUB_EP_DESC_BASE 0x08 158 #define AST_VHUB_EP_DESC_STATUS 0x0C 159 160 /* EP config reg */ 161 #define VHUB_EP_CFG_SET_MAX_PKT(x) (((x) & 0x3ff) << 16) 162 #define VHUB_EP_CFG_AUTO_DATA_DISABLE (1 << 13) 163 #define VHUB_EP_CFG_STALL_CTRL (1 << 12) 164 #define VHUB_EP_CFG_SET_EP_NUM(x) (((x) & 0xf) << 8) 165 #define VHUB_EP_CFG_SET_TYPE(x) ((x) << 5) 166 #define EP_TYPE_OFF 0 167 #define EP_TYPE_BULK 1 168 #define EP_TYPE_INT 2 169 #define EP_TYPE_ISO 3 170 #define VHUB_EP_CFG_DIR_OUT (1 << 4) 171 #define VHUB_EP_CFG_SET_DEV(x) ((x) << 1) 172 #define VHUB_EP_CFG_ENABLE (1 << 0) 173 174 /* EP DMA control */ 175 #define VHUB_EP_DMA_PROC_STATUS(x) (((x) >> 4) & 0xf) 176 #define EP_DMA_PROC_RX_IDLE 0 177 #define EP_DMA_PROC_TX_IDLE 8 178 #define VHUB_EP_DMA_IN_LONG_MODE (1 << 3) 179 #define VHUB_EP_DMA_OUT_CONTIG_MODE (1 << 3) 180 #define VHUB_EP_DMA_CTRL_RESET (1 << 2) 181 #define VHUB_EP_DMA_SINGLE_STAGE (1 << 1) 182 #define VHUB_EP_DMA_DESC_MODE (1 << 0) 183 184 /* EP DMA status */ 185 #define VHUB_EP_DMA_SET_TX_SIZE(x) ((x) << 16) 186 #define VHUB_EP_DMA_TX_SIZE(x) (((x) >> 16) & 0x7ff) 187 #define VHUB_EP_DMA_RPTR(x) (((x) >> 8) & 0xff) 188 #define VHUB_EP_DMA_SET_RPTR(x) (((x) & 0xff) << 8) 189 #define VHUB_EP_DMA_SET_CPU_WPTR(x) (x) 190 #define VHUB_EP_DMA_SINGLE_KICK (1 << 0) /* WPTR = 1 for single mode */ 191 192 /******************************* 193 * * 194 * DMA descriptors definitions * 195 * * 196 *******************************/ 197 198 /* Desc W1 IN */ 199 #define VHUB_DSC1_IN_INTERRUPT (1 << 31) 200 #define VHUB_DSC1_IN_SPID_DATA0 (0 << 14) 201 #define VHUB_DSC1_IN_SPID_DATA2 (1 << 14) 202 #define VHUB_DSC1_IN_SPID_DATA1 (2 << 14) 203 #define VHUB_DSC1_IN_SPID_MDATA (3 << 14) 204 #define VHUB_DSC1_IN_SET_LEN(x) ((x) & 0xfff) 205 #define VHUB_DSC1_IN_LEN(x) ((x) & 0xfff) 206 207 /**************************************** 208 * * 209 * Data structures and misc definitions * 210 * * 211 ****************************************/ 212 213 #define AST_VHUB_NUM_GEN_EPs 15 /* Generic non-0 EPs */ 214 #define AST_VHUB_NUM_PORTS 5 /* vHub ports */ 215 #define AST_VHUB_EP0_MAX_PACKET 64 /* EP0's max packet size */ 216 #define AST_VHUB_EPn_MAX_PACKET 1024 /* Generic EPs max packet size */ 217 #define AST_VHUB_DESCS_COUNT 256 /* Use 256 descriptor mode (valid 218 * values are 256 and 32) 219 */ 220 221 struct ast_vhub; 222 struct ast_vhub_dev; 223 224 /* 225 * DMA descriptor (generic EPs only, currently only used 226 * for IN endpoints 227 */ 228 struct ast_vhub_desc { 229 __le32 w0; 230 __le32 w1; 231 }; 232 233 /* A transfer request, either core-originated or internal */ 234 struct ast_vhub_req { 235 struct usb_request req; 236 struct list_head queue; 237 238 /* Actual count written to descriptors (desc mode only) */ 239 unsigned int act_count; 240 241 /* 242 * Desc number of the final packet or -1. For non-desc 243 * mode (or ep0), any >= 0 value means "last packet" 244 */ 245 int last_desc; 246 247 /* Request active (pending DMAs) */ 248 bool active : 1; 249 250 /* Internal request (don't call back core) */ 251 bool internal : 1; 252 }; 253 #define to_ast_req(__ureq) container_of(__ureq, struct ast_vhub_req, req) 254 255 /* Current state of an EP0 */ 256 enum ep0_state { 257 ep0_state_token, 258 ep0_state_data, 259 ep0_state_status, 260 }; 261 262 /* 263 * An endpoint, either generic, ep0, actual gadget EP 264 * or internal use vhub EP0. vhub EP1 doesn't have an 265 * associated structure as it's mostly HW managed. 266 */ 267 struct ast_vhub_ep { 268 struct usb_ep ep; 269 270 /* Request queue */ 271 struct list_head queue; 272 273 /* EP index in the device, 0 means this is an EP0 */ 274 unsigned int d_idx; 275 276 /* Dev pointer or NULL for vHub EP0 */ 277 struct ast_vhub_dev *dev; 278 279 /* vHub itself */ 280 struct ast_vhub *vhub; 281 282 /* 283 * DMA buffer for EP0, fallback DMA buffer for misaligned 284 * OUT transfers for generic EPs 285 */ 286 void *buf; 287 dma_addr_t buf_dma; 288 289 /* The rest depends on the EP type */ 290 union { 291 /* EP0 (either device or vhub) */ 292 struct { 293 /* 294 * EP0 registers are "similar" for 295 * vHub and devices but located in 296 * different places. 297 */ 298 void __iomem *ctlstat; 299 void __iomem *setup; 300 301 /* Current state & direction */ 302 enum ep0_state state; 303 bool dir_in; 304 305 /* Internal use request */ 306 struct ast_vhub_req req; 307 } ep0; 308 309 /* Generic endpoint (aka EPn) */ 310 struct { 311 /* Registers */ 312 void __iomem *regs; 313 314 /* Index in global pool (0..14) */ 315 unsigned int g_idx; 316 317 /* DMA Descriptors */ 318 struct ast_vhub_desc *descs; 319 dma_addr_t descs_dma; 320 unsigned int d_next; 321 unsigned int d_last; 322 unsigned int dma_conf; 323 324 /* Max chunk size for IN EPs */ 325 unsigned int chunk_max; 326 327 /* State flags */ 328 bool is_in : 1; 329 bool is_iso : 1; 330 bool stalled : 1; 331 bool wedged : 1; 332 bool enabled : 1; 333 bool desc_mode : 1; 334 } epn; 335 }; 336 }; 337 #define to_ast_ep(__uep) container_of(__uep, struct ast_vhub_ep, ep) 338 339 /* A device attached to a vHub port */ 340 struct ast_vhub_dev { 341 struct ast_vhub *vhub; 342 void __iomem *regs; 343 344 /* Device index (0...4) and name string */ 345 unsigned int index; 346 const char *name; 347 348 /* sysfs enclosure for the gadget gunk */ 349 struct device *port_dev; 350 351 /* Link to gadget core */ 352 struct usb_gadget gadget; 353 struct usb_gadget_driver *driver; 354 bool registered : 1; 355 bool wakeup_en : 1; 356 bool suspended : 1; 357 bool enabled : 1; 358 359 /* Endpoint structures */ 360 struct ast_vhub_ep ep0; 361 struct ast_vhub_ep *epns[AST_VHUB_NUM_GEN_EPs]; 362 363 }; 364 #define to_ast_dev(__g) container_of(__g, struct ast_vhub_dev, gadget) 365 366 /* Per vhub port stateinfo structure */ 367 struct ast_vhub_port { 368 /* Port status & status change registers */ 369 u16 status; 370 u16 change; 371 372 /* Associated device slot */ 373 struct ast_vhub_dev dev; 374 }; 375 376 /* Global vhub structure */ 377 struct ast_vhub { 378 struct platform_device *pdev; 379 void __iomem *regs; 380 int irq; 381 spinlock_t lock; 382 struct work_struct wake_work; 383 struct clk *clk; 384 385 /* EP0 DMA buffers allocated in one chunk */ 386 void *ep0_bufs; 387 dma_addr_t ep0_bufs_dma; 388 389 /* EP0 of the vhub itself */ 390 struct ast_vhub_ep ep0; 391 392 /* State of vhub ep1 */ 393 bool ep1_stalled : 1; 394 395 /* Per-port info */ 396 struct ast_vhub_port ports[AST_VHUB_NUM_PORTS]; 397 398 /* Generic EP data structures */ 399 struct ast_vhub_ep epns[AST_VHUB_NUM_GEN_EPs]; 400 401 /* Upstream bus is suspended ? */ 402 bool suspended : 1; 403 404 /* Hub itself can signal remote wakeup */ 405 bool wakeup_en : 1; 406 407 /* Force full speed only */ 408 bool force_usb1 : 1; 409 410 /* Upstream bus speed captured at bus reset */ 411 unsigned int speed; 412 }; 413 414 /* Standard request handlers result codes */ 415 enum std_req_rc { 416 std_req_stall = -1, /* Stall requested */ 417 std_req_complete = 0, /* Request completed with no data */ 418 std_req_data = 1, /* Request completed with data */ 419 std_req_driver = 2, /* Pass to driver pls */ 420 }; 421 422 #ifdef CONFIG_USB_GADGET_VERBOSE 423 #define UDCVDBG(u, fmt...) dev_dbg(&(u)->pdev->dev, fmt) 424 425 #define EPVDBG(ep, fmt, ...) do { \ 426 dev_dbg(&(ep)->vhub->pdev->dev, \ 427 "%s:EP%d " fmt, \ 428 (ep)->dev ? (ep)->dev->name : "hub", \ 429 (ep)->d_idx, ##__VA_ARGS__); \ 430 } while(0) 431 432 #define DVDBG(d, fmt, ...) do { \ 433 dev_dbg(&(d)->vhub->pdev->dev, \ 434 "%s " fmt, (d)->name, \ 435 ##__VA_ARGS__); \ 436 } while(0) 437 438 #else 439 #define UDCVDBG(u, fmt...) do { } while(0) 440 #define EPVDBG(ep, fmt, ...) do { } while(0) 441 #define DVDBG(d, fmt, ...) do { } while(0) 442 #endif 443 444 #ifdef CONFIG_USB_GADGET_DEBUG 445 #define UDCDBG(u, fmt...) dev_dbg(&(u)->pdev->dev, fmt) 446 447 #define EPDBG(ep, fmt, ...) do { \ 448 dev_dbg(&(ep)->vhub->pdev->dev, \ 449 "%s:EP%d " fmt, \ 450 (ep)->dev ? (ep)->dev->name : "hub", \ 451 (ep)->d_idx, ##__VA_ARGS__); \ 452 } while(0) 453 454 #define DDBG(d, fmt, ...) do { \ 455 dev_dbg(&(d)->vhub->pdev->dev, \ 456 "%s " fmt, (d)->name, \ 457 ##__VA_ARGS__); \ 458 } while(0) 459 #else 460 #define UDCDBG(u, fmt...) do { } while(0) 461 #define EPDBG(ep, fmt, ...) do { } while(0) 462 #define DDBG(d, fmt, ...) do { } while(0) 463 #endif 464 465 static inline void vhub_dma_workaround(void *addr) 466 { 467 /* 468 * This works around a confirmed HW issue with the Aspeed chip. 469 * 470 * The core uses a different bus to memory than the AHB going to 471 * the USB device controller. Due to the latter having a higher 472 * priority than the core for arbitration on that bus, it's 473 * possible for an MMIO to the device, followed by a DMA by the 474 * device from memory to all be performed and services before 475 * a previous store to memory gets completed. 476 * 477 * This the following scenario can happen: 478 * 479 * - Driver writes to a DMA descriptor (Mbus) 480 * - Driver writes to the MMIO register to start the DMA (AHB) 481 * - The gadget sees the second write and sends a read of the 482 * descriptor to the memory controller (Mbus) 483 * - The gadget hits memory before the descriptor write 484 * causing it to read an obsolete value. 485 * 486 * Thankfully the problem is limited to the USB gadget device, other 487 * masters in the SoC all have a lower priority than the core, thus 488 * ensuring that the store by the core arrives first. 489 * 490 * The workaround consists of using a dummy read of the memory before 491 * doing the MMIO writes. This will ensure that the previous writes 492 * have been "pushed out". 493 */ 494 mb(); 495 (void)__raw_readl((void __iomem *)addr); 496 } 497 498 /* core.c */ 499 void ast_vhub_done(struct ast_vhub_ep *ep, struct ast_vhub_req *req, 500 int status); 501 void ast_vhub_nuke(struct ast_vhub_ep *ep, int status); 502 struct usb_request *ast_vhub_alloc_request(struct usb_ep *u_ep, 503 gfp_t gfp_flags); 504 void ast_vhub_free_request(struct usb_ep *u_ep, struct usb_request *u_req); 505 void ast_vhub_init_hw(struct ast_vhub *vhub); 506 507 /* ep0.c */ 508 void ast_vhub_ep0_handle_ack(struct ast_vhub_ep *ep, bool in_ack); 509 void ast_vhub_ep0_handle_setup(struct ast_vhub_ep *ep); 510 void ast_vhub_init_ep0(struct ast_vhub *vhub, struct ast_vhub_ep *ep, 511 struct ast_vhub_dev *dev); 512 int ast_vhub_reply(struct ast_vhub_ep *ep, char *ptr, int len); 513 int __ast_vhub_simple_reply(struct ast_vhub_ep *ep, int len, ...); 514 #define ast_vhub_simple_reply(udc, ...) \ 515 __ast_vhub_simple_reply((udc), \ 516 sizeof((u8[]) { __VA_ARGS__ })/sizeof(u8), \ 517 __VA_ARGS__) 518 519 /* hub.c */ 520 void ast_vhub_init_hub(struct ast_vhub *vhub); 521 enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep, 522 struct usb_ctrlrequest *crq); 523 enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep, 524 struct usb_ctrlrequest *crq); 525 void ast_vhub_device_connect(struct ast_vhub *vhub, unsigned int port, 526 bool on); 527 void ast_vhub_hub_suspend(struct ast_vhub *vhub); 528 void ast_vhub_hub_resume(struct ast_vhub *vhub); 529 void ast_vhub_hub_reset(struct ast_vhub *vhub); 530 void ast_vhub_hub_wake_all(struct ast_vhub *vhub); 531 532 /* dev.c */ 533 int ast_vhub_init_dev(struct ast_vhub *vhub, unsigned int idx); 534 void ast_vhub_del_dev(struct ast_vhub_dev *d); 535 void ast_vhub_dev_irq(struct ast_vhub_dev *d); 536 int ast_vhub_std_dev_request(struct ast_vhub_ep *ep, 537 struct usb_ctrlrequest *crq); 538 539 /* epn.c */ 540 void ast_vhub_epn_ack_irq(struct ast_vhub_ep *ep); 541 void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep); 542 struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr); 543 void ast_vhub_dev_suspend(struct ast_vhub_dev *d); 544 void ast_vhub_dev_resume(struct ast_vhub_dev *d); 545 void ast_vhub_dev_reset(struct ast_vhub_dev *d); 546 547 #endif /* __ASPEED_VHUB_H */ 548