drivers/usb/host/xen-hcd.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * xen-hcd.c
   4  *
   5  * Xen USB Virtual Host Controller driver
   6  *
   7  * Copyright (C) 2009, FUJITSU LABORATORIES LTD.
   8  * Author: Noboru Iwamatsu <n_iwamatsu@jp.fujitsu.com>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/usb.h>
  13 #include <linux/list.h>
  14 #include <linux/usb/hcd.h>
  15 #include <linux/io.h>
  16
  17 #include <xen/xen.h>
  18 #include <xen/xenbus.h>
  19 #include <xen/grant_table.h>
  20 #include <xen/events.h>
  21 #include <xen/page.h>
  22
  23 #include <xen/interface/io/usbif.h>
  24
  25 /* Private per-URB data */
  26 struct urb_priv {
  27         struct list_head list;
  28         struct urb *urb;
  29         int req_id;             /* RING_REQUEST id for submitting */
  30         int unlink_req_id;      /* RING_REQUEST id for unlinking */
  31         int status;
  32         bool unlinked;          /* dequeued marker */
  33 };
  34
  35 /* virtual roothub port status */
  36 struct rhport_status {
  37         __u32 status;
  38         bool resuming;          /* in resuming */
  39         bool c_connection;      /* connection changed */
  40         unsigned long timeout;
  41 };
  42
  43 /* status of attached device */
  44 struct vdevice_status {
  45         int devnum;
  46         enum usb_device_state status;
  47         enum usb_device_speed speed;
  48 };
  49
  50 /* RING request shadow */
  51 struct usb_shadow {
  52         struct xenusb_urb_request req;
  53         struct urb *urb;
  54         bool in_flight;
  55 };
  56
  57 struct xenhcd_info {
  58         /* Virtual Host Controller has 4 urb queues */
  59         struct list_head pending_submit_list;
  60         struct list_head pending_unlink_list;
  61         struct list_head in_progress_list;
  62         struct list_head giveback_waiting_list;
  63
  64         spinlock_t lock;
  65
  66         /* timer that kick pending and giveback waiting urbs */
  67         struct timer_list watchdog;
  68         unsigned long actions;
  69
  70         /* virtual root hub */
  71         int rh_numports;
  72         struct rhport_status ports[XENUSB_MAX_PORTNR];
  73         struct vdevice_status devices[XENUSB_MAX_PORTNR];
  74
  75         /* Xen related staff */
  76         struct xenbus_device *xbdev;
  77         int urb_ring_ref;
  78         int conn_ring_ref;
  79         struct xenusb_urb_front_ring urb_ring;
  80         struct xenusb_conn_front_ring conn_ring;
  81
  82         unsigned int evtchn;
  83         unsigned int irq;
  84         struct usb_shadow shadow[XENUSB_URB_RING_SIZE];
  85         unsigned int shadow_free;
  86
  87         bool error;
  88 };
  89
  90 #define XENHCD_RING_JIFFIES (HZ/200)
  91 #define XENHCD_SCAN_JIFFIES 1
  92
  93 enum xenhcd_timer_action {
  94         TIMER_RING_WATCHDOG,
  95         TIMER_SCAN_PENDING_URBS,
  96 };
  97
  98 static struct kmem_cache *xenhcd_urbp_cachep;
  99
 100 static inline struct xenhcd_info *xenhcd_hcd_to_info(struct usb_hcd *hcd)
 101 {
 102         return (struct xenhcd_info *)hcd->hcd_priv;
 103 }
 104
 105 static inline struct usb_hcd *xenhcd_info_to_hcd(struct xenhcd_info *info)
 106 {
 107         return container_of((void *)info, struct usb_hcd, hcd_priv);
 108 }
 109
 110 static void xenhcd_set_error(struct xenhcd_info *info, const char *msg)
 111 {
 112         info->error = true;
 113
 114         pr_alert("xen-hcd: protocol error: %s!\n", msg);
 115 }
 116
 117 static inline void xenhcd_timer_action_done(struct xenhcd_info *info,
 118                                             enum xenhcd_timer_action action)
 119 {
 120         clear_bit(action, &info->actions);
 121 }
 122
 123 static void xenhcd_timer_action(struct xenhcd_info *info,
 124                                 enum xenhcd_timer_action action)
 125 {
 126         if (timer_pending(&info->watchdog) &&
 127             test_bit(TIMER_SCAN_PENDING_URBS, &info->actions))
 128                 return;
 129
 130         if (!test_and_set_bit(action, &info->actions)) {
 131                 unsigned long t;
 132
 133                 switch (action) {
 134                 case TIMER_RING_WATCHDOG:
 135                         t = XENHCD_RING_JIFFIES;
 136                         break;
 137                 default:
 138                         t = XENHCD_SCAN_JIFFIES;
 139                         break;
 140                 }
 141                 mod_timer(&info->watchdog, t + jiffies);
 142         }
 143 }
 144
 145 /*
 146  * set virtual port connection status
 147  */
 148 static void xenhcd_set_connect_state(struct xenhcd_info *info, int portnum)
 149 {
 150         int port;
 151
 152         port = portnum - 1;
 153         if (info->ports[port].status & USB_PORT_STAT_POWER) {
 154                 switch (info->devices[port].speed) {
 155                 case XENUSB_SPEED_NONE:
 156                         info->ports[port].status &=
 157                                 ~(USB_PORT_STAT_CONNECTION |
 158                                   USB_PORT_STAT_ENABLE |
 159                                   USB_PORT_STAT_LOW_SPEED |
 160                                   USB_PORT_STAT_HIGH_SPEED |
 161                                   USB_PORT_STAT_SUSPEND);
 162                         break;
 163                 case XENUSB_SPEED_LOW:
 164                         info->ports[port].status |= USB_PORT_STAT_CONNECTION;
 165                         info->ports[port].status |= USB_PORT_STAT_LOW_SPEED;
 166                         break;
 167                 case XENUSB_SPEED_FULL:
 168                         info->ports[port].status |= USB_PORT_STAT_CONNECTION;
 169                         break;
 170                 case XENUSB_SPEED_HIGH:
 171                         info->ports[port].status |= USB_PORT_STAT_CONNECTION;
 172                         info->ports[port].status |= USB_PORT_STAT_HIGH_SPEED;
 173                         break;
 174                 default: /* error */
 175                         return;
 176                 }
 177                 info->ports[port].status |= (USB_PORT_STAT_C_CONNECTION << 16);
 178         }
 179 }
 180
 181 /*
 182  * set virtual device connection status
 183  */
 184 static int xenhcd_rhport_connect(struct xenhcd_info *info, __u8 portnum,
 185                                  __u8 speed)
 186 {
 187         int port;
 188
 189         if (portnum < 1 || portnum > info->rh_numports)
 190                 return -EINVAL; /* invalid port number */
 191
 192         port = portnum - 1;
 193         if (info->devices[port].speed != speed) {
 194                 switch (speed) {
 195                 case XENUSB_SPEED_NONE: /* disconnect */
 196                         info->devices[port].status = USB_STATE_NOTATTACHED;
 197                         break;
 198                 case XENUSB_SPEED_LOW:
 199                 case XENUSB_SPEED_FULL:
 200                 case XENUSB_SPEED_HIGH:
 201                         info->devices[port].status = USB_STATE_ATTACHED;
 202                         break;
 203                 default: /* error */
 204                         return -EINVAL;
 205                 }
 206                 info->devices[port].speed = speed;
 207                 info->ports[port].c_connection = true;
 208
 209                 xenhcd_set_connect_state(info, portnum);
 210         }
 211
 212         return 0;
 213 }
 214
 215 /*
 216  * SetPortFeature(PORT_SUSPENDED)
 217  */
 218 static void xenhcd_rhport_suspend(struct xenhcd_info *info, int portnum)
 219 {
 220         int port;
 221
 222         port = portnum - 1;
 223         info->ports[port].status |= USB_PORT_STAT_SUSPEND;
 224         info->devices[port].status = USB_STATE_SUSPENDED;
 225 }
 226
 227 /*
 228  * ClearPortFeature(PORT_SUSPENDED)
 229  */
 230 static void xenhcd_rhport_resume(struct xenhcd_info *info, int portnum)
 231 {
 232         int port;
 233
 234         port = portnum - 1;
 235         if (info->ports[port].status & USB_PORT_STAT_SUSPEND) {
 236                 info->ports[port].resuming = true;
 237                 info->ports[port].timeout = jiffies + msecs_to_jiffies(20);
 238         }
 239 }
 240
 241 /*
 242  * SetPortFeature(PORT_POWER)
 243  */
 244 static void xenhcd_rhport_power_on(struct xenhcd_info *info, int portnum)
 245 {
 246         int port;
 247
 248         port = portnum - 1;
 249         if ((info->ports[port].status & USB_PORT_STAT_POWER) == 0) {
 250                 info->ports[port].status |= USB_PORT_STAT_POWER;
 251                 if (info->devices[port].status != USB_STATE_NOTATTACHED)
 252                         info->devices[port].status = USB_STATE_POWERED;
 253                 if (info->ports[port].c_connection)
 254                         xenhcd_set_connect_state(info, portnum);
 255         }
 256 }
 257
 258 /*
 259  * ClearPortFeature(PORT_POWER)
 260  * SetConfiguration(non-zero)
 261  * Power_Source_Off
 262  * Over-current
 263  */
 264 static void xenhcd_rhport_power_off(struct xenhcd_info *info, int portnum)
 265 {
 266         int port;
 267
 268         port = portnum - 1;
 269         if (info->ports[port].status & USB_PORT_STAT_POWER) {
 270                 info->ports[port].status = 0;
 271                 if (info->devices[port].status != USB_STATE_NOTATTACHED)
 272                         info->devices[port].status = USB_STATE_ATTACHED;
 273         }
 274 }
 275
 276 /*
 277  * ClearPortFeature(PORT_ENABLE)
 278  */
 279 static void xenhcd_rhport_disable(struct xenhcd_info *info, int portnum)
 280 {
 281         int port;
 282
 283         port = portnum - 1;
 284         info->ports[port].status &= ~USB_PORT_STAT_ENABLE;
 285         info->ports[port].status &= ~USB_PORT_STAT_SUSPEND;
 286         info->ports[port].resuming = false;
 287         if (info->devices[port].status != USB_STATE_NOTATTACHED)
 288                 info->devices[port].status = USB_STATE_POWERED;
 289 }
 290
 291 /*
 292  * SetPortFeature(PORT_RESET)
 293  */
 294 static void xenhcd_rhport_reset(struct xenhcd_info *info, int portnum)
 295 {
 296         int port;
 297
 298         port = portnum - 1;
 299         info->ports[port].status &= ~(USB_PORT_STAT_ENABLE |
 300                                       USB_PORT_STAT_LOW_SPEED |
 301                                       USB_PORT_STAT_HIGH_SPEED);
 302         info->ports[port].status |= USB_PORT_STAT_RESET;
 303
 304         if (info->devices[port].status != USB_STATE_NOTATTACHED)
 305                 info->devices[port].status = USB_STATE_ATTACHED;
 306
 307         /* 10msec reset signaling */
 308         info->ports[port].timeout = jiffies + msecs_to_jiffies(10);
 309 }
 310
 311 #ifdef CONFIG_PM
 312 static int xenhcd_bus_suspend(struct usb_hcd *hcd)
 313 {
 314         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
 315         int ret = 0;
 316         int i, ports;
 317
 318         ports = info->rh_numports;
 319
 320         spin_lock_irq(&info->lock);
 321         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
 322                 ret = -ESHUTDOWN;
 323         } else {
 324                 /* suspend any active ports*/
 325                 for (i = 1; i <= ports; i++)
 326                         xenhcd_rhport_suspend(info, i);
 327         }
 328         spin_unlock_irq(&info->lock);
 329
 330         del_timer_sync(&info->watchdog);
 331
 332         return ret;
 333 }
 334
 335 static int xenhcd_bus_resume(struct usb_hcd *hcd)
 336 {
 337         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
 338         int ret = 0;
 339         int i, ports;
 340
 341         ports = info->rh_numports;
 342
 343         spin_lock_irq(&info->lock);
 344         if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
 345                 ret = -ESHUTDOWN;
 346         } else {
 347                 /* resume any suspended ports*/
 348                 for (i = 1; i <= ports; i++)
 349                         xenhcd_rhport_resume(info, i);
 350         }
 351         spin_unlock_irq(&info->lock);
 352
 353         return ret;
 354 }
 355 #endif
 356
 357 static void xenhcd_hub_descriptor(struct xenhcd_info *info,
 358                                   struct usb_hub_descriptor *desc)
 359 {
 360         __u16 temp;
 361         int ports = info->rh_numports;
 362
 363         desc->bDescriptorType = 0x29;
 364         desc->bPwrOn2PwrGood = 10; /* EHCI says 20ms max */
 365         desc->bHubContrCurrent = 0;
 366         desc->bNbrPorts = ports;
 367
 368         /* size of DeviceRemovable and PortPwrCtrlMask fields */
 369         temp = 1 + (ports / 8);
 370         desc->bDescLength = 7 + 2 * temp;
 371
 372         /* bitmaps for DeviceRemovable and PortPwrCtrlMask */
 373         memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
 374         memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
 375
 376         /* per-port over current reporting and no power switching */
 377         temp = 0x000a;
 378         desc->wHubCharacteristics = cpu_to_le16(temp);
 379 }
 380
 381 /* port status change mask for hub_status_data */
 382 #define PORT_C_MASK     ((USB_PORT_STAT_C_CONNECTION |          \
 383                           USB_PORT_STAT_C_ENABLE |              \
 384                           USB_PORT_STAT_C_SUSPEND |             \
 385                           USB_PORT_STAT_C_OVERCURRENT |         \
 386                           USB_PORT_STAT_C_RESET) << 16)
 387
 388 /*
 389  * See USB 2.0 Spec, 11.12.4 Hub and Port Status Change Bitmap.
 390  * If port status changed, writes the bitmap to buf and return
 391  * that length(number of bytes).
 392  * If Nothing changed, return 0.
 393  */
 394 static int xenhcd_hub_status_data(struct usb_hcd *hcd, char *buf)
 395 {
 396         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
 397         int ports;
 398         int i;
 399         unsigned long flags;
 400         int ret;
 401         int changed = 0;
 402
 403         /* initialize the status to no-changes */
 404         ports = info->rh_numports;
 405         ret = 1 + (ports / 8);
 406         memset(buf, 0, ret);
 407
 408         spin_lock_irqsave(&info->lock, flags);
 409
 410         for (i = 0; i < ports; i++) {
 411                 /* check status for each port */
 412                 if (info->ports[i].status & PORT_C_MASK) {
 413                         buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
 414                         changed = 1;
 415                 }
 416         }
 417
 418         if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1))
 419                 usb_hcd_resume_root_hub(hcd);
 420
 421         spin_unlock_irqrestore(&info->lock, flags);
 422
 423         return changed ? ret : 0;
 424 }
 425
 426 static int xenhcd_hub_control(struct usb_hcd *hcd, __u16 typeReq, __u16 wValue,
 427                               __u16 wIndex, char *buf, __u16 wLength)
 428 {
 429         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
 430         int ports = info->rh_numports;
 431         unsigned long flags;
 432         int ret = 0;
 433         int i;
 434         int changed = 0;
 435
 436         spin_lock_irqsave(&info->lock, flags);
 437         switch (typeReq) {
 438         case ClearHubFeature:
 439                 /* ignore this request */
 440                 break;
 441         case ClearPortFeature:
 442                 if (!wIndex || wIndex > ports)
 443                         goto error;
 444
 445                 switch (wValue) {
 446                 case USB_PORT_FEAT_SUSPEND:
 447                         xenhcd_rhport_resume(info, wIndex);
 448                         break;
 449                 case USB_PORT_FEAT_POWER:
 450                         xenhcd_rhport_power_off(info, wIndex);
 451                         break;
 452                 case USB_PORT_FEAT_ENABLE:
 453                         xenhcd_rhport_disable(info, wIndex);
 454                         break;
 455                 case USB_PORT_FEAT_C_CONNECTION:
 456                         info->ports[wIndex - 1].c_connection = false;
 457                         fallthrough;
 458                 default:
 459                         info->ports[wIndex - 1].status &= ~(1 << wValue);
 460                         break;
 461                 }
 462                 break;
 463         case GetHubDescriptor:
 464                 xenhcd_hub_descriptor(info, (struct usb_hub_descriptor *)buf);
 465                 break;
 466         case GetHubStatus:
 467                 /* always local power supply good and no over-current exists. */
 468                 *(__le32 *)buf = cpu_to_le32(0);
 469                 break;
 470         case GetPortStatus:
 471                 if (!wIndex || wIndex > ports)
 472                         goto error;
 473
 474                 wIndex--;
 475
 476                 /* resume completion */
 477                 if (info->ports[wIndex].resuming &&
 478                     time_after_eq(jiffies, info->ports[wIndex].timeout)) {
 479                         info->ports[wIndex].status |=
 480                                 USB_PORT_STAT_C_SUSPEND << 16;
 481                         info->ports[wIndex].status &= ~USB_PORT_STAT_SUSPEND;
 482                 }
 483
 484                 /* reset completion */
 485                 if ((info->ports[wIndex].status & USB_PORT_STAT_RESET) != 0 &&
 486                     time_after_eq(jiffies, info->ports[wIndex].timeout)) {
 487                         info->ports[wIndex].status |=
 488                                 USB_PORT_STAT_C_RESET << 16;
 489                         info->ports[wIndex].status &= ~USB_PORT_STAT_RESET;
 490
 491                         if (info->devices[wIndex].status !=
 492                             USB_STATE_NOTATTACHED) {
 493                                 info->ports[wIndex].status |=
 494                                         USB_PORT_STAT_ENABLE;
 495                                 info->devices[wIndex].status =
 496                                         USB_STATE_DEFAULT;
 497                         }
 498
 499                         switch (info->devices[wIndex].speed) {
 500                         case XENUSB_SPEED_LOW:
 501                                 info->ports[wIndex].status |=
 502                                         USB_PORT_STAT_LOW_SPEED;
 503                                 break;
 504                         case XENUSB_SPEED_HIGH:
 505                                 info->ports[wIndex].status |=
 506                                         USB_PORT_STAT_HIGH_SPEED;
 507                                 break;
 508                         default:
 509                                 break;
 510                         }
 511                 }
 512
 513                 *(__le32 *)buf = cpu_to_le32(info->ports[wIndex].status);
 514                 break;
 515         case SetPortFeature:
 516                 if (!wIndex || wIndex > ports)
 517                         goto error;
 518
 519                 switch (wValue) {
 520                 case USB_PORT_FEAT_POWER:
 521                         xenhcd_rhport_power_on(info, wIndex);
 522                         break;
 523                 case USB_PORT_FEAT_RESET:
 524                         xenhcd_rhport_reset(info, wIndex);
 525                         break;
 526                 case USB_PORT_FEAT_SUSPEND:
 527                         xenhcd_rhport_suspend(info, wIndex);
 528                         break;
 529                 default:
 530                         if (info->ports[wIndex-1].status & USB_PORT_STAT_POWER)
 531                                 info->ports[wIndex-1].status |= (1 << wValue);
 532                 }
 533                 break;
 534
 535         case SetHubFeature:
 536                 /* not supported */
 537         default:
 538 error:
 539                 ret = -EPIPE;
 540         }
 541         spin_unlock_irqrestore(&info->lock, flags);
 542
 543         /* check status for each port */
 544         for (i = 0; i < ports; i++) {
 545                 if (info->ports[i].status & PORT_C_MASK)
 546                         changed = 1;
 547         }
 548         if (changed)
 549                 usb_hcd_poll_rh_status(hcd);
 550
 551         return ret;
 552 }
 553
 554 static void xenhcd_free_urb_priv(struct urb_priv *urbp)
 555 {
 556         urbp->urb->hcpriv = NULL;
 557         kmem_cache_free(xenhcd_urbp_cachep, urbp);
 558 }
 559
 560 static inline unsigned int xenhcd_get_id_from_freelist(struct xenhcd_info *info)
 561 {
 562         unsigned int free;
 563
 564         free = info->shadow_free;
 565         info->shadow_free = info->shadow[free].req.id;
 566         info->shadow[free].req.id = 0x0fff; /* debug */
 567         return free;
 568 }
 569
 570 static inline void xenhcd_add_id_to_freelist(struct xenhcd_info *info,
 571                                              unsigned int id)
 572 {
 573         info->shadow[id].req.id = info->shadow_free;
 574         info->shadow[id].urb = NULL;
 575         info->shadow_free = id;
 576 }
 577
 578 static inline int xenhcd_count_pages(void *addr, int length)
 579 {
 580         unsigned long vaddr = (unsigned long)addr;
 581
 582         return PFN_UP(vaddr + length) - PFN_DOWN(vaddr);
 583 }
 584
 585 static void xenhcd_gnttab_map(struct xenhcd_info *info, void *addr, int length,
 586                               grant_ref_t *gref_head,
 587                               struct xenusb_request_segment *seg,
 588                               int nr_pages, int flags)
 589 {
 590         grant_ref_t ref;
 591         unsigned int offset;
 592         unsigned int len = length;
 593         unsigned int bytes;
 594         int i;
 595
 596         for (i = 0; i < nr_pages; i++) {
 597                 offset = offset_in_page(addr);
 598
 599                 bytes = PAGE_SIZE - offset;
 600                 if (bytes > len)
 601                         bytes = len;
 602
 603                 ref = gnttab_claim_grant_reference(gref_head);
 604                 gnttab_grant_foreign_access_ref(ref, info->xbdev->otherend_id,
 605                                                 virt_to_gfn(addr), flags);
 606                 seg[i].gref = ref;
 607                 seg[i].offset = (__u16)offset;
 608                 seg[i].length = (__u16)bytes;
 609
 610                 addr += bytes;
 611                 len -= bytes;
 612         }
 613 }
 614
 615 static __u32 xenhcd_pipe_urb_to_xenusb(__u32 urb_pipe, __u8 port)
 616 {
 617         static __u32 pipe;
 618
 619         pipe = usb_pipedevice(urb_pipe) << XENUSB_PIPE_DEV_SHIFT;
 620         pipe |= usb_pipeendpoint(urb_pipe) << XENUSB_PIPE_EP_SHIFT;
 621         if (usb_pipein(urb_pipe))
 622                 pipe |= XENUSB_PIPE_DIR;
 623         switch (usb_pipetype(urb_pipe)) {
 624         case PIPE_ISOCHRONOUS:
 625                 pipe |= XENUSB_PIPE_TYPE_ISOC << XENUSB_PIPE_TYPE_SHIFT;
 626                 break;
 627         case PIPE_INTERRUPT:
 628                 pipe |= XENUSB_PIPE_TYPE_INT << XENUSB_PIPE_TYPE_SHIFT;
 629                 break;
 630         case PIPE_CONTROL:
 631                 pipe |= XENUSB_PIPE_TYPE_CTRL << XENUSB_PIPE_TYPE_SHIFT;
 632                 break;
 633         case PIPE_BULK:
 634                 pipe |= XENUSB_PIPE_TYPE_BULK << XENUSB_PIPE_TYPE_SHIFT;
 635                 break;
 636         }
 637         pipe = xenusb_setportnum_pipe(pipe, port);
 638
 639         return pipe;
 640 }
 641
 642 static int xenhcd_map_urb_for_request(struct xenhcd_info *info, struct urb *urb,
 643                                       struct xenusb_urb_request *req)
 644 {
 645         grant_ref_t gref_head;
 646         int nr_buff_pages = 0;
 647         int nr_isodesc_pages = 0;
 648         int nr_grants = 0;
 649
 650         if (urb->transfer_buffer_length) {
 651                 nr_buff_pages = xenhcd_count_pages(urb->transfer_buffer,
 652                                                 urb->transfer_buffer_length);
 653
 654                 if (usb_pipeisoc(urb->pipe))
 655                         nr_isodesc_pages = xenhcd_count_pages(
 656                                 &urb->iso_frame_desc[0],
 657                                 sizeof(struct usb_iso_packet_descriptor) *
 658                                 urb->number_of_packets);
 659
 660                 nr_grants = nr_buff_pages + nr_isodesc_pages;
 661                 if (nr_grants > XENUSB_MAX_SEGMENTS_PER_REQUEST) {
 662                         pr_err("xenhcd: error: %d grants\n", nr_grants);
 663                         return -E2BIG;
 664                 }
 665
 666                 if (gnttab_alloc_grant_references(nr_grants, &gref_head)) {
 667                         pr_err("xenhcd: gnttab_alloc_grant_references() error\n");
 668                         return -ENOMEM;
 669                 }
 670
 671                 xenhcd_gnttab_map(info, urb->transfer_buffer,
 672                                   urb->transfer_buffer_length, &gref_head,
 673                                   &req->seg[0], nr_buff_pages,
 674                                   usb_pipein(urb->pipe) ? 0 : GTF_readonly);
 675         }
 676
 677         req->pipe = xenhcd_pipe_urb_to_xenusb(urb->pipe, urb->dev->portnum);
 678         req->transfer_flags = 0;
 679         if (urb->transfer_flags & URB_SHORT_NOT_OK)
 680                 req->transfer_flags |= XENUSB_SHORT_NOT_OK;
 681         req->buffer_length = urb->transfer_buffer_length;
 682         req->nr_buffer_segs = nr_buff_pages;
 683
 684         switch (usb_pipetype(urb->pipe)) {
 685         case PIPE_ISOCHRONOUS:
 686                 req->u.isoc.interval = urb->interval;
 687                 req->u.isoc.start_frame = urb->start_frame;
 688                 req->u.isoc.number_of_packets = urb->number_of_packets;
 689                 req->u.isoc.nr_frame_desc_segs = nr_isodesc_pages;
 690
 691                 xenhcd_gnttab_map(info, &urb->iso_frame_desc[0],
 692                                   sizeof(struct usb_iso_packet_descriptor) *
 693                                   urb->number_of_packets,
 694                                   &gref_head, &req->seg[nr_buff_pages],
 695                                   nr_isodesc_pages, 0);
 696                 break;
 697         case PIPE_INTERRUPT:
 698                 req->u.intr.interval = urb->interval;
 699                 break;
 700         case PIPE_CONTROL:
 701                 if (urb->setup_packet)
 702                         memcpy(req->u.ctrl, urb->setup_packet, 8);
 703                 break;
 704         case PIPE_BULK:
 705                 break;
 706         default:
 707                 break;
 708         }
 709
 710         if (nr_grants)
 711                 gnttab_free_grant_references(gref_head);
 712
 713         return 0;
 714 }
 715
 716 static void xenhcd_gnttab_done(struct xenhcd_info *info, unsigned int id)
 717 {
 718         struct usb_shadow *shadow = info->shadow + id;
 719         int nr_segs = 0;
 720         int i;
 721
 722         if (!shadow->in_flight) {
 723                 xenhcd_set_error(info, "Illegal request id");
 724                 return;
 725         }
 726         shadow->in_flight = false;
 727
 728         nr_segs = shadow->req.nr_buffer_segs;
 729
 730         if (xenusb_pipeisoc(shadow->req.pipe))
 731                 nr_segs += shadow->req.u.isoc.nr_frame_desc_segs;
 732
 733         for (i = 0; i < nr_segs; i++) {
 734                 if (!gnttab_try_end_foreign_access(shadow->req.seg[i].gref))
 735                         xenhcd_set_error(info, "backend didn't release grant");
 736         }
 737
 738         shadow->req.nr_buffer_segs = 0;
 739         shadow->req.u.isoc.nr_frame_desc_segs = 0;
 740 }
 741
 742 static int xenhcd_translate_status(int status)
 743 {
 744         switch (status) {
 745         case XENUSB_STATUS_OK:
 746                 return 0;
 747         case XENUSB_STATUS_NODEV:
 748                 return -ENODEV;
 749         case XENUSB_STATUS_INVAL:
 750                 return -EINVAL;
 751         case XENUSB_STATUS_STALL:
 752                 return -EPIPE;
 753         case XENUSB_STATUS_IOERROR:
 754                 return -EPROTO;
 755         case XENUSB_STATUS_BABBLE:
 756                 return -EOVERFLOW;
 757         default:
 758                 return -ESHUTDOWN;
 759         }
 760 }
 761
 762 static void xenhcd_giveback_urb(struct xenhcd_info *info, struct urb *urb,
 763                                 int status)
 764 {
 765         struct urb_priv *urbp = (struct urb_priv *)urb->hcpriv;
 766         int priv_status = urbp->status;
 767
 768         list_del_init(&urbp->list);
 769         xenhcd_free_urb_priv(urbp);
 770
 771         if (urb->status == -EINPROGRESS)
 772                 urb->status = xenhcd_translate_status(status);
 773
 774         spin_unlock(&info->lock);
 775         usb_hcd_giveback_urb(xenhcd_info_to_hcd(info), urb,
 776                              priv_status <= 0 ? priv_status : urb->status);
 777         spin_lock(&info->lock);
 778 }
 779
 780 static int xenhcd_do_request(struct xenhcd_info *info, struct urb_priv *urbp)
 781 {
 782         struct xenusb_urb_request *req;
 783         struct urb *urb = urbp->urb;
 784         unsigned int id;
 785         int notify;
 786         int ret;
 787
 788         id = xenhcd_get_id_from_freelist(info);
 789         req = &info->shadow[id].req;
 790         req->id = id;
 791
 792         if (unlikely(urbp->unlinked)) {
 793                 req->u.unlink.unlink_id = urbp->req_id;
 794                 req->pipe = xenusb_setunlink_pipe(xenhcd_pipe_urb_to_xenusb(
 795                                                  urb->pipe, urb->dev->portnum));
 796                 urbp->unlink_req_id = id;
 797         } else {
 798                 ret = xenhcd_map_urb_for_request(info, urb, req);
 799                 if (ret) {
 800                         xenhcd_add_id_to_freelist(info, id);
 801                         return ret;
 802                 }
 803                 urbp->req_id = id;
 804         }
 805
 806         req = RING_GET_REQUEST(&info->urb_ring, info->urb_ring.req_prod_pvt);
 807         *req = info->shadow[id].req;
 808
 809         info->urb_ring.req_prod_pvt++;
 810         info->shadow[id].urb = urb;
 811         info->shadow[id].in_flight = true;
 812
 813         RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->urb_ring, notify);
 814         if (notify)
 815                 notify_remote_via_irq(info->irq);
 816
 817         return 0;
 818 }
 819
 820 static void xenhcd_kick_pending_urbs(struct xenhcd_info *info)
 821 {
 822         struct urb_priv *urbp;
 823
 824         while (!list_empty(&info->pending_submit_list)) {
 825                 if (RING_FULL(&info->urb_ring)) {
 826                         xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
 827                         return;
 828                 }
 829
 830                 urbp = list_entry(info->pending_submit_list.next,
 831                                   struct urb_priv, list);
 832                 if (!xenhcd_do_request(info, urbp))
 833                         list_move_tail(&urbp->list, &info->in_progress_list);
 834                 else
 835                         xenhcd_giveback_urb(info, urbp->urb, -ESHUTDOWN);
 836         }
 837         xenhcd_timer_action_done(info, TIMER_SCAN_PENDING_URBS);
 838 }
 839
 840 /*
 841  * caller must lock info->lock
 842  */
 843 static void xenhcd_cancel_all_enqueued_urbs(struct xenhcd_info *info)
 844 {
 845         struct urb_priv *urbp, *tmp;
 846         int req_id;
 847
 848         list_for_each_entry_safe(urbp, tmp, &info->in_progress_list, list) {
 849                 req_id = urbp->req_id;
 850                 if (!urbp->unlinked) {
 851                         xenhcd_gnttab_done(info, req_id);
 852                         if (info->error)
 853                                 return;
 854                         if (urbp->urb->status == -EINPROGRESS)
 855                                 /* not dequeued */
 856                                 xenhcd_giveback_urb(info, urbp->urb,
 857                                                     -ESHUTDOWN);
 858                         else    /* dequeued */
 859                                 xenhcd_giveback_urb(info, urbp->urb,
 860                                                     urbp->urb->status);
 861                 }
 862                 info->shadow[req_id].urb = NULL;
 863         }
 864
 865         list_for_each_entry_safe(urbp, tmp, &info->pending_submit_list, list)
 866                 xenhcd_giveback_urb(info, urbp->urb, -ESHUTDOWN);
 867 }
 868
 869 /*
 870  * caller must lock info->lock
 871  */
 872 static void xenhcd_giveback_unlinked_urbs(struct xenhcd_info *info)
 873 {
 874         struct urb_priv *urbp, *tmp;
 875
 876         list_for_each_entry_safe(urbp, tmp, &info->giveback_waiting_list, list)
 877                 xenhcd_giveback_urb(info, urbp->urb, urbp->urb->status);
 878 }
 879
 880 static int xenhcd_submit_urb(struct xenhcd_info *info, struct urb_priv *urbp)
 881 {
 882         int ret;
 883
 884         if (RING_FULL(&info->urb_ring)) {
 885                 list_add_tail(&urbp->list, &info->pending_submit_list);
 886                 xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
 887                 return 0;
 888         }
 889
 890         if (!list_empty(&info->pending_submit_list)) {
 891                 list_add_tail(&urbp->list, &info->pending_submit_list);
 892                 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
 893                 return 0;
 894         }
 895
 896         ret = xenhcd_do_request(info, urbp);
 897         if (ret == 0)
 898                 list_add_tail(&urbp->list, &info->in_progress_list);
 899
 900         return ret;
 901 }
 902
 903 static int xenhcd_unlink_urb(struct xenhcd_info *info, struct urb_priv *urbp)
 904 {
 905         int ret;
 906
 907         /* already unlinked? */
 908         if (urbp->unlinked)
 909                 return -EBUSY;
 910
 911         urbp->unlinked = true;
 912
 913         /* the urb is still in pending_submit queue */
 914         if (urbp->req_id == ~0) {
 915                 list_move_tail(&urbp->list, &info->giveback_waiting_list);
 916                 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
 917                 return 0;
 918         }
 919
 920         /* send unlink request to backend */
 921         if (RING_FULL(&info->urb_ring)) {
 922                 list_move_tail(&urbp->list, &info->pending_unlink_list);
 923                 xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
 924                 return 0;
 925         }
 926
 927         if (!list_empty(&info->pending_unlink_list)) {
 928                 list_move_tail(&urbp->list, &info->pending_unlink_list);
 929                 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
 930                 return 0;
 931         }
 932
 933         ret = xenhcd_do_request(info, urbp);
 934         if (ret == 0)
 935                 list_move_tail(&urbp->list, &info->in_progress_list);
 936
 937         return ret;
 938 }
 939
 940 static void xenhcd_res_to_urb(struct xenhcd_info *info,
 941                               struct xenusb_urb_response *res, struct urb *urb)
 942 {
 943         if (unlikely(!urb))
 944                 return;
 945
 946         if (res->actual_length > urb->transfer_buffer_length)
 947                 urb->actual_length = urb->transfer_buffer_length;
 948         else if (res->actual_length < 0)
 949                 urb->actual_length = 0;
 950         else
 951                 urb->actual_length = res->actual_length;
 952         urb->error_count = res->error_count;
 953         urb->start_frame = res->start_frame;
 954         xenhcd_giveback_urb(info, urb, res->status);
 955 }
 956
 957 static int xenhcd_urb_request_done(struct xenhcd_info *info,
 958                                    unsigned int *eoiflag)
 959 {
 960         struct xenusb_urb_response res;
 961         RING_IDX i, rp;
 962         __u16 id;
 963         int more_to_do = 0;
 964         unsigned long flags;
 965
 966         spin_lock_irqsave(&info->lock, flags);
 967
 968         rp = info->urb_ring.sring->rsp_prod;
 969         if (RING_RESPONSE_PROD_OVERFLOW(&info->urb_ring, rp)) {
 970                 xenhcd_set_error(info, "Illegal index on urb-ring");
 971                 goto err;
 972         }
 973         rmb(); /* ensure we see queued responses up to "rp" */
 974
 975         for (i = info->urb_ring.rsp_cons; i != rp; i++) {
 976                 RING_COPY_RESPONSE(&info->urb_ring, i, &res);
 977                 id = res.id;
 978                 if (id >= XENUSB_URB_RING_SIZE) {
 979                         xenhcd_set_error(info, "Illegal data on urb-ring");
 980                         goto err;
 981                 }
 982
 983                 if (likely(xenusb_pipesubmit(info->shadow[id].req.pipe))) {
 984                         xenhcd_gnttab_done(info, id);
 985                         if (info->error)
 986                                 goto err;
 987                         xenhcd_res_to_urb(info, &res, info->shadow[id].urb);
 988                 }
 989
 990                 xenhcd_add_id_to_freelist(info, id);
 991
 992                 *eoiflag = 0;
 993         }
 994         info->urb_ring.rsp_cons = i;
 995
 996         if (i != info->urb_ring.req_prod_pvt)
 997                 RING_FINAL_CHECK_FOR_RESPONSES(&info->urb_ring, more_to_do);
 998         else
 999                 info->urb_ring.sring->rsp_event = i + 1;
1000
1001         spin_unlock_irqrestore(&info->lock, flags);
1002
1003         return more_to_do;
1004
1005  err:
1006         spin_unlock_irqrestore(&info->lock, flags);
1007         return 0;
1008 }
1009
1010 static int xenhcd_conn_notify(struct xenhcd_info *info, unsigned int *eoiflag)
1011 {
1012         struct xenusb_conn_response res;
1013         struct xenusb_conn_request *req;
1014         RING_IDX rc, rp;
1015         __u16 id;
1016         __u8 portnum, speed;
1017         int more_to_do = 0;
1018         int notify;
1019         int port_changed = 0;
1020         unsigned long flags;
1021
1022         spin_lock_irqsave(&info->lock, flags);
1023
1024         rc = info->conn_ring.rsp_cons;
1025         rp = info->conn_ring.sring->rsp_prod;
1026         if (RING_RESPONSE_PROD_OVERFLOW(&info->conn_ring, rp)) {
1027                 xenhcd_set_error(info, "Illegal index on conn-ring");
1028                 spin_unlock_irqrestore(&info->lock, flags);
1029                 return 0;
1030         }
1031         rmb(); /* ensure we see queued responses up to "rp" */
1032
1033         while (rc != rp) {
1034                 RING_COPY_RESPONSE(&info->conn_ring, rc, &res);
1035                 id = res.id;
1036                 portnum = res.portnum;
1037                 speed = res.speed;
1038                 info->conn_ring.rsp_cons = ++rc;
1039
1040                 if (xenhcd_rhport_connect(info, portnum, speed)) {
1041                         xenhcd_set_error(info, "Illegal data on conn-ring");
1042                         spin_unlock_irqrestore(&info->lock, flags);
1043                         return 0;
1044                 }
1045
1046                 if (info->ports[portnum - 1].c_connection)
1047                         port_changed = 1;
1048
1049                 barrier();
1050
1051                 req = RING_GET_REQUEST(&info->conn_ring,
1052                                        info->conn_ring.req_prod_pvt);
1053                 req->id = id;
1054                 info->conn_ring.req_prod_pvt++;
1055
1056                 *eoiflag = 0;
1057         }
1058
1059         if (rc != info->conn_ring.req_prod_pvt)
1060                 RING_FINAL_CHECK_FOR_RESPONSES(&info->conn_ring, more_to_do);
1061         else
1062                 info->conn_ring.sring->rsp_event = rc + 1;
1063
1064         RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->conn_ring, notify);
1065         if (notify)
1066                 notify_remote_via_irq(info->irq);
1067
1068         spin_unlock_irqrestore(&info->lock, flags);
1069
1070         if (port_changed)
1071                 usb_hcd_poll_rh_status(xenhcd_info_to_hcd(info));
1072
1073         return more_to_do;
1074 }
1075
1076 static irqreturn_t xenhcd_int(int irq, void *dev_id)
1077 {
1078         struct xenhcd_info *info = (struct xenhcd_info *)dev_id;
1079         unsigned int eoiflag = XEN_EOI_FLAG_SPURIOUS;
1080
1081         if (unlikely(info->error)) {
1082                 xen_irq_lateeoi(irq, XEN_EOI_FLAG_SPURIOUS);
1083                 return IRQ_HANDLED;
1084         }
1085
1086         while (xenhcd_urb_request_done(info, &eoiflag) |
1087                xenhcd_conn_notify(info, &eoiflag))
1088                 /* Yield point for this unbounded loop. */
1089                 cond_resched();
1090
1091         xen_irq_lateeoi(irq, eoiflag);
1092         return IRQ_HANDLED;
1093 }
1094
1095 static void xenhcd_destroy_rings(struct xenhcd_info *info)
1096 {
1097         if (info->irq)
1098                 unbind_from_irqhandler(info->irq, info);
1099         info->irq = 0;
1100
1101         xenbus_teardown_ring((void **)&info->urb_ring.sring, 1,
1102                              &info->urb_ring_ref);
1103         xenbus_teardown_ring((void **)&info->conn_ring.sring, 1,
1104                              &info->conn_ring_ref);
1105 }
1106
1107 static int xenhcd_setup_rings(struct xenbus_device *dev,
1108                               struct xenhcd_info *info)
1109 {
1110         struct xenusb_urb_sring *urb_sring;
1111         struct xenusb_conn_sring *conn_sring;
1112         int err;
1113
1114         info->conn_ring_ref = INVALID_GRANT_REF;
1115         err = xenbus_setup_ring(dev, GFP_NOIO | __GFP_HIGH,
1116                                 (void **)&urb_sring, 1, &info->urb_ring_ref);
1117         if (err) {
1118                 xenbus_dev_fatal(dev, err, "allocating urb ring");
1119                 return err;
1120         }
1121         XEN_FRONT_RING_INIT(&info->urb_ring, urb_sring, PAGE_SIZE);
1122
1123         err = xenbus_setup_ring(dev, GFP_NOIO | __GFP_HIGH,
1124                                 (void **)&conn_sring, 1, &info->conn_ring_ref);
1125         if (err) {
1126                 xenbus_dev_fatal(dev, err, "allocating conn ring");
1127                 goto fail;
1128         }
1129         XEN_FRONT_RING_INIT(&info->conn_ring, conn_sring, PAGE_SIZE);
1130
1131         err = xenbus_alloc_evtchn(dev, &info->evtchn);
1132         if (err) {
1133                 xenbus_dev_fatal(dev, err, "xenbus_alloc_evtchn");
1134                 goto fail;
1135         }
1136
1137         err = bind_evtchn_to_irq_lateeoi(info->evtchn);
1138         if (err <= 0) {
1139                 xenbus_dev_fatal(dev, err, "bind_evtchn_to_irq_lateeoi");
1140                 goto fail;
1141         }
1142
1143         info->irq = err;
1144
1145         err = request_threaded_irq(info->irq, NULL, xenhcd_int,
1146                                    IRQF_ONESHOT, "xenhcd", info);
1147         if (err) {
1148                 xenbus_dev_fatal(dev, err, "request_threaded_irq");
1149                 goto free_irq;
1150         }
1151
1152         return 0;
1153
1154 free_irq:
1155         unbind_from_irqhandler(info->irq, info);
1156 fail:
1157         xenhcd_destroy_rings(info);
1158         return err;
1159 }
1160
1161 static int xenhcd_talk_to_backend(struct xenbus_device *dev,
1162                                   struct xenhcd_info *info)
1163 {
1164         const char *message;
1165         struct xenbus_transaction xbt;
1166         int err;
1167
1168         err = xenhcd_setup_rings(dev, info);
1169         if (err)
1170                 return err;
1171
1172 again:
1173         err = xenbus_transaction_start(&xbt);
1174         if (err) {
1175                 xenbus_dev_fatal(dev, err, "starting transaction");
1176                 goto destroy_ring;
1177         }
1178
1179         err = xenbus_printf(xbt, dev->nodename, "urb-ring-ref", "%u",
1180                             info->urb_ring_ref);
1181         if (err) {
1182                 message = "writing urb-ring-ref";
1183                 goto abort_transaction;
1184         }
1185
1186         err = xenbus_printf(xbt, dev->nodename, "conn-ring-ref", "%u",
1187                             info->conn_ring_ref);
1188         if (err) {
1189                 message = "writing conn-ring-ref";
1190                 goto abort_transaction;
1191         }
1192
1193         err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
1194                             info->evtchn);
1195         if (err) {
1196                 message = "writing event-channel";
1197                 goto abort_transaction;
1198         }
1199
1200         err = xenbus_transaction_end(xbt, 0);
1201         if (err) {
1202                 if (err == -EAGAIN)
1203                         goto again;
1204                 xenbus_dev_fatal(dev, err, "completing transaction");
1205                 goto destroy_ring;
1206         }
1207
1208         return 0;
1209
1210 abort_transaction:
1211         xenbus_transaction_end(xbt, 1);
1212         xenbus_dev_fatal(dev, err, "%s", message);
1213
1214 destroy_ring:
1215         xenhcd_destroy_rings(info);
1216
1217         return err;
1218 }
1219
1220 static int xenhcd_connect(struct xenbus_device *dev)
1221 {
1222         struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1223         struct xenusb_conn_request *req;
1224         int idx, err;
1225         int notify;
1226         char name[TASK_COMM_LEN];
1227         struct usb_hcd *hcd;
1228
1229         hcd = xenhcd_info_to_hcd(info);
1230         snprintf(name, TASK_COMM_LEN, "xenhcd.%d", hcd->self.busnum);
1231
1232         err = xenhcd_talk_to_backend(dev, info);
1233         if (err)
1234                 return err;
1235
1236         /* prepare ring for hotplug notification */
1237         for (idx = 0; idx < XENUSB_CONN_RING_SIZE; idx++) {
1238                 req = RING_GET_REQUEST(&info->conn_ring, idx);
1239                 req->id = idx;
1240         }
1241         info->conn_ring.req_prod_pvt = idx;
1242
1243         RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->conn_ring, notify);
1244         if (notify)
1245                 notify_remote_via_irq(info->irq);
1246
1247         return 0;
1248 }
1249
1250 static void xenhcd_disconnect(struct xenbus_device *dev)
1251 {
1252         struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1253         struct usb_hcd *hcd = xenhcd_info_to_hcd(info);
1254
1255         usb_remove_hcd(hcd);
1256         xenbus_frontend_closed(dev);
1257 }
1258
1259 static void xenhcd_watchdog(struct timer_list *timer)
1260 {
1261         struct xenhcd_info *info = from_timer(info, timer, watchdog);
1262         unsigned long flags;
1263
1264         spin_lock_irqsave(&info->lock, flags);
1265         if (likely(HC_IS_RUNNING(xenhcd_info_to_hcd(info)->state))) {
1266                 xenhcd_timer_action_done(info, TIMER_RING_WATCHDOG);
1267                 xenhcd_giveback_unlinked_urbs(info);
1268                 xenhcd_kick_pending_urbs(info);
1269         }
1270         spin_unlock_irqrestore(&info->lock, flags);
1271 }
1272
1273 /*
1274  * one-time HC init
1275  */
1276 static int xenhcd_setup(struct usb_hcd *hcd)
1277 {
1278         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1279
1280         spin_lock_init(&info->lock);
1281         INIT_LIST_HEAD(&info->pending_submit_list);
1282         INIT_LIST_HEAD(&info->pending_unlink_list);
1283         INIT_LIST_HEAD(&info->in_progress_list);
1284         INIT_LIST_HEAD(&info->giveback_waiting_list);
1285         timer_setup(&info->watchdog, xenhcd_watchdog, 0);
1286
1287         hcd->has_tt = (hcd->driver->flags & HCD_MASK) != HCD_USB11;
1288
1289         return 0;
1290 }
1291
1292 /*
1293  * start HC running
1294  */
1295 static int xenhcd_run(struct usb_hcd *hcd)
1296 {
1297         hcd->uses_new_polling = 1;
1298         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1299         hcd->state = HC_STATE_RUNNING;
1300         return 0;
1301 }
1302
1303 /*
1304  * stop running HC
1305  */
1306 static void xenhcd_stop(struct usb_hcd *hcd)
1307 {
1308         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1309
1310         del_timer_sync(&info->watchdog);
1311         spin_lock_irq(&info->lock);
1312         /* cancel all urbs */
1313         hcd->state = HC_STATE_HALT;
1314         xenhcd_cancel_all_enqueued_urbs(info);
1315         xenhcd_giveback_unlinked_urbs(info);
1316         spin_unlock_irq(&info->lock);
1317 }
1318
1319 /*
1320  * called as .urb_enqueue()
1321  * non-error returns are promise to giveback the urb later
1322  */
1323 static int xenhcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
1324                               gfp_t mem_flags)
1325 {
1326         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1327         struct urb_priv *urbp;
1328         unsigned long flags;
1329         int ret;
1330
1331         if (unlikely(info->error))
1332                 return -ESHUTDOWN;
1333
1334         urbp = kmem_cache_zalloc(xenhcd_urbp_cachep, mem_flags);
1335         if (!urbp)
1336                 return -ENOMEM;
1337
1338         spin_lock_irqsave(&info->lock, flags);
1339
1340         urbp->urb = urb;
1341         urb->hcpriv = urbp;
1342         urbp->req_id = ~0;
1343         urbp->unlink_req_id = ~0;
1344         INIT_LIST_HEAD(&urbp->list);
1345         urbp->status = 1;
1346         urb->unlinked = false;
1347
1348         ret = xenhcd_submit_urb(info, urbp);
1349
1350         if (ret)
1351                 xenhcd_free_urb_priv(urbp);
1352
1353         spin_unlock_irqrestore(&info->lock, flags);
1354
1355         return ret;
1356 }
1357
1358 /*
1359  * called as .urb_dequeue()
1360  */
1361 static int xenhcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1362 {
1363         struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1364         struct urb_priv *urbp;
1365         unsigned long flags;
1366         int ret = 0;
1367
1368         spin_lock_irqsave(&info->lock, flags);
1369
1370         urbp = urb->hcpriv;
1371         if (urbp) {
1372                 urbp->status = status;
1373                 ret = xenhcd_unlink_urb(info, urbp);
1374         }
1375
1376         spin_unlock_irqrestore(&info->lock, flags);
1377
1378         return ret;
1379 }
1380
1381 /*
1382  * called from usb_get_current_frame_number(),
1383  * but, almost all drivers not use such function.
1384  */
1385 static int xenhcd_get_frame(struct usb_hcd *hcd)
1386 {
1387         /* it means error, but probably no problem :-) */
1388         return 0;
1389 }
1390
1391 static struct hc_driver xenhcd_usb20_hc_driver = {
1392         .description = "xen-hcd",
1393         .product_desc = "Xen USB2.0 Virtual Host Controller",
1394         .hcd_priv_size = sizeof(struct xenhcd_info),
1395         .flags = HCD_USB2,
1396
1397         /* basic HC lifecycle operations */
1398         .reset = xenhcd_setup,
1399         .start = xenhcd_run,
1400         .stop = xenhcd_stop,
1401
1402         /* managing urb I/O */
1403         .urb_enqueue = xenhcd_urb_enqueue,
1404         .urb_dequeue = xenhcd_urb_dequeue,
1405         .get_frame_number = xenhcd_get_frame,
1406
1407         /* root hub operations */
1408         .hub_status_data = xenhcd_hub_status_data,
1409         .hub_control = xenhcd_hub_control,
1410 #ifdef CONFIG_PM
1411         .bus_suspend = xenhcd_bus_suspend,
1412         .bus_resume = xenhcd_bus_resume,
1413 #endif
1414 };
1415
1416 static struct hc_driver xenhcd_usb11_hc_driver = {
1417         .description = "xen-hcd",
1418         .product_desc = "Xen USB1.1 Virtual Host Controller",
1419         .hcd_priv_size = sizeof(struct xenhcd_info),
1420         .flags = HCD_USB11,
1421
1422         /* basic HC lifecycle operations */
1423         .reset = xenhcd_setup,
1424         .start = xenhcd_run,
1425         .stop = xenhcd_stop,
1426
1427         /* managing urb I/O */
1428         .urb_enqueue = xenhcd_urb_enqueue,
1429         .urb_dequeue = xenhcd_urb_dequeue,
1430         .get_frame_number = xenhcd_get_frame,
1431
1432         /* root hub operations */
1433         .hub_status_data = xenhcd_hub_status_data,
1434         .hub_control = xenhcd_hub_control,
1435 #ifdef CONFIG_PM
1436         .bus_suspend = xenhcd_bus_suspend,
1437         .bus_resume = xenhcd_bus_resume,
1438 #endif
1439 };
1440
1441 static struct usb_hcd *xenhcd_create_hcd(struct xenbus_device *dev)
1442 {
1443         int i;
1444         int err = 0;
1445         int num_ports;
1446         int usb_ver;
1447         struct usb_hcd *hcd = NULL;
1448         struct xenhcd_info *info;
1449
1450         err = xenbus_scanf(XBT_NIL, dev->otherend, "num-ports", "%d",
1451                            &num_ports);
1452         if (err != 1) {
1453                 xenbus_dev_fatal(dev, err, "reading num-ports");
1454                 return ERR_PTR(-EINVAL);
1455         }
1456         if (num_ports < 1 || num_ports > XENUSB_MAX_PORTNR) {
1457                 xenbus_dev_fatal(dev, err, "invalid num-ports");
1458                 return ERR_PTR(-EINVAL);
1459         }
1460
1461         err = xenbus_scanf(XBT_NIL, dev->otherend, "usb-ver", "%d", &usb_ver);
1462         if (err != 1) {
1463                 xenbus_dev_fatal(dev, err, "reading usb-ver");
1464                 return ERR_PTR(-EINVAL);
1465         }
1466         switch (usb_ver) {
1467         case XENUSB_VER_USB11:
1468                 hcd = usb_create_hcd(&xenhcd_usb11_hc_driver, &dev->dev,
1469                                      dev_name(&dev->dev));
1470                 break;
1471         case XENUSB_VER_USB20:
1472                 hcd = usb_create_hcd(&xenhcd_usb20_hc_driver, &dev->dev,
1473                                      dev_name(&dev->dev));
1474                 break;
1475         default:
1476                 xenbus_dev_fatal(dev, err, "invalid usb-ver");
1477                 return ERR_PTR(-EINVAL);
1478         }
1479         if (!hcd) {
1480                 xenbus_dev_fatal(dev, err,
1481                                  "fail to allocate USB host controller");
1482                 return ERR_PTR(-ENOMEM);
1483         }
1484
1485         info = xenhcd_hcd_to_info(hcd);
1486         info->xbdev = dev;
1487         info->rh_numports = num_ports;
1488
1489         for (i = 0; i < XENUSB_URB_RING_SIZE; i++) {
1490                 info->shadow[i].req.id = i + 1;
1491                 info->shadow[i].urb = NULL;
1492                 info->shadow[i].in_flight = false;
1493         }
1494         info->shadow[XENUSB_URB_RING_SIZE - 1].req.id = 0x0fff;
1495
1496         return hcd;
1497 }
1498
1499 static void xenhcd_backend_changed(struct xenbus_device *dev,
1500                                    enum xenbus_state backend_state)
1501 {
1502         switch (backend_state) {
1503         case XenbusStateInitialising:
1504         case XenbusStateReconfiguring:
1505         case XenbusStateReconfigured:
1506         case XenbusStateUnknown:
1507                 break;
1508
1509         case XenbusStateInitWait:
1510         case XenbusStateInitialised:
1511         case XenbusStateConnected:
1512                 if (dev->state != XenbusStateInitialising)
1513                         break;
1514                 if (!xenhcd_connect(dev))
1515                         xenbus_switch_state(dev, XenbusStateConnected);
1516                 break;
1517
1518         case XenbusStateClosed:
1519                 if (dev->state == XenbusStateClosed)
1520                         break;
1521                 fallthrough;    /* Missed the backend's Closing state. */
1522         case XenbusStateClosing:
1523                 xenhcd_disconnect(dev);
1524                 break;
1525
1526         default:
1527                 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
1528                                  backend_state);
1529                 break;
1530         }
1531 }
1532
1533 static void xenhcd_remove(struct xenbus_device *dev)
1534 {
1535         struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1536         struct usb_hcd *hcd = xenhcd_info_to_hcd(info);
1537
1538         xenhcd_destroy_rings(info);
1539         usb_put_hcd(hcd);
1540 }
1541
1542 static int xenhcd_probe(struct xenbus_device *dev,
1543                         const struct xenbus_device_id *id)
1544 {
1545         int err;
1546         struct usb_hcd *hcd;
1547         struct xenhcd_info *info;
1548
1549         if (usb_disabled())
1550                 return -ENODEV;
1551
1552         hcd = xenhcd_create_hcd(dev);
1553         if (IS_ERR(hcd)) {
1554                 err = PTR_ERR(hcd);
1555                 xenbus_dev_fatal(dev, err,
1556                                  "fail to create usb host controller");
1557                 return err;
1558         }
1559
1560         info = xenhcd_hcd_to_info(hcd);
1561         dev_set_drvdata(&dev->dev, info);
1562
1563         err = usb_add_hcd(hcd, 0, 0);
1564         if (err) {
1565                 xenbus_dev_fatal(dev, err, "fail to add USB host controller");
1566                 usb_put_hcd(hcd);
1567                 dev_set_drvdata(&dev->dev, NULL);
1568         }
1569
1570         return err;
1571 }
1572
1573 static const struct xenbus_device_id xenhcd_ids[] = {
1574         { "vusb" },
1575         { "" },
1576 };
1577
1578 static struct xenbus_driver xenhcd_driver = {
1579         .ids                    = xenhcd_ids,
1580         .probe                  = xenhcd_probe,
1581         .otherend_changed       = xenhcd_backend_changed,
1582         .remove                 = xenhcd_remove,
1583 };
1584
1585 static int __init xenhcd_init(void)
1586 {
1587         if (!xen_domain())
1588                 return -ENODEV;
1589
1590         xenhcd_urbp_cachep = kmem_cache_create("xenhcd_urb_priv",
1591                                         sizeof(struct urb_priv), 0, 0, NULL);
1592         if (!xenhcd_urbp_cachep) {
1593                 pr_err("xenhcd failed to create kmem cache\n");
1594                 return -ENOMEM;
1595         }
1596
1597         return xenbus_register_frontend(&xenhcd_driver);
1598 }
1599 module_init(xenhcd_init);
1600
1601 static void __exit xenhcd_exit(void)
1602 {
1603         kmem_cache_destroy(xenhcd_urbp_cachep);
1604         xenbus_unregister_driver(&xenhcd_driver);
1605 }
1606 module_exit(xenhcd_exit);
1607
1608 MODULE_ALIAS("xen:vusb");
1609 MODULE_AUTHOR("Juergen Gross <jgross@suse.com>");
1610 MODULE_DESCRIPTION("Xen USB Virtual Host Controller driver (xen-hcd)");
1611 MODULE_LICENSE("Dual BSD/GPL");