iPXE
uhci.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 #include <strings.h>
27 #include <unistd.h>
28 #include <errno.h>
29 #include <byteswap.h>
30 #include <ipxe/malloc.h>
31 #include <ipxe/pci.h>
32 #include <ipxe/usb.h>
33 #include "ehci.h"
34 #include "uhci.h"
35 
36 /** @file
37  *
38  * USB Universal Host Controller Interface (UHCI) driver
39  *
40  */
41 
42 /******************************************************************************
43  *
44  * Register access
45  *
46  ******************************************************************************
47  */
48 
49 /**
50  * Check that address is reachable
51  *
52  * @v addr Address
53  * @v len Length
54  * @ret rc Return status code
55  */
56 static inline __attribute__ (( always_inline)) int
57 uhci_reachable ( void *addr, size_t len ) {
59 
60  /* Always reachable in a 32-bit build */
61  if ( sizeof ( physaddr_t ) <= sizeof ( uint32_t ) )
62  return 0;
63 
64  /* Reachable if below 4GB */
65  if ( ( ( phys + len - 1 ) & ~0xffffffffULL ) == 0 )
66  return 0;
67 
68  return -ENOTSUP;
69 }
70 
71 /******************************************************************************
72  *
73  * Run / stop / reset
74  *
75  ******************************************************************************
76  */
77 
78 /**
79  * Start UHCI device
80  *
81  * @v uhci UHCI device
82  */
83 static void uhci_run ( struct uhci_device *uhci ) {
84  uint16_t usbcmd;
85 
86  /* Set run/stop bit */
87  usbcmd = inw ( uhci->regs + UHCI_USBCMD );
88  usbcmd |= ( UHCI_USBCMD_RUN | UHCI_USBCMD_MAX64 );
89  outw ( usbcmd, uhci->regs + UHCI_USBCMD );
90 }
91 
92 /**
93  * Stop UHCI device
94  *
95  * @v uhci UHCI device
96  * @ret rc Return status code
97  */
98 static int uhci_stop ( struct uhci_device *uhci ) {
99  uint16_t usbcmd;
100  uint16_t usbsts;
101  unsigned int i;
102 
103  /* Clear run/stop bit */
104  usbcmd = inw ( uhci->regs + UHCI_USBCMD );
105  usbcmd &= ~UHCI_USBCMD_RUN;
106  outw ( usbcmd, uhci->regs + UHCI_USBCMD );
107 
108  /* Wait for device to stop */
109  for ( i = 0 ; i < UHCI_STOP_MAX_WAIT_MS ; i++ ) {
110 
111  /* Check if device is stopped */
112  usbsts = inw ( uhci->regs + UHCI_USBSTS );
113  if ( usbsts & UHCI_USBSTS_HCHALTED )
114  return 0;
115 
116  /* Delay */
117  mdelay ( 1 );
118  }
119 
120  DBGC ( uhci, "UHCI %s timed out waiting for stop\n", uhci->name );
121  return -ETIMEDOUT;
122 }
123 
124 /**
125  * Reset UHCI device
126  *
127  * @v uhci UHCI device
128  * @ret rc Return status code
129  */
130 static int uhci_reset ( struct uhci_device *uhci ) {
131  uint16_t usbcmd;
132  unsigned int i;
133  int rc;
134 
135  /* The UHCI specification states that resetting a running
136  * device may result in undefined behaviour, so try stopping
137  * it first.
138  */
139  if ( ( rc = uhci_stop ( uhci ) ) != 0 ) {
140  /* Ignore errors and attempt to reset the device anyway */
141  }
142 
143  /* Reset device */
145 
146  /* Wait for reset to complete */
147  for ( i = 0 ; i < UHCI_RESET_MAX_WAIT_MS ; i++ ) {
148 
149  /* Check if reset is complete */
150  usbcmd = inw ( uhci->regs + UHCI_USBCMD );
151  if ( ! ( usbcmd & UHCI_USBCMD_HCRESET ) )
152  return 0;
153 
154  /* Delay */
155  mdelay ( 1 );
156  }
157 
158  DBGC ( uhci, "UHCI %s timed out waiting for reset\n", uhci->name );
159  return -ETIMEDOUT;
160 }
161 
162 /******************************************************************************
163  *
164  * Transfer descriptor rings
165  *
166  ******************************************************************************
167  */
168 
169 /**
170  * Allocate transfer ring
171  *
172  * @v ring Transfer ring
173  * @ret rc Return status code
174  */
175 static int uhci_ring_alloc ( struct uhci_ring *ring ) {
176  int rc;
177 
178  /* Initialise structure */
179  memset ( ring, 0, sizeof ( *ring ) );
180 
181  /* Allocate queue head */
182  ring->head = malloc_dma ( sizeof ( *ring->head ), UHCI_ALIGN );
183  if ( ! ring->head ) {
184  rc = -ENOMEM;
185  goto err_alloc;
186  }
187  if ( ( rc = uhci_reachable ( ring->head,
188  sizeof ( *ring->head ) ) ) != 0 )
189  goto err_unreachable;
190 
191  /* Initialise queue head */
193 
194  return 0;
195 
196  err_unreachable:
197  free_dma ( ring->head, sizeof ( *ring->head ) );
198  err_alloc:
199  return rc;
200 }
201 
202 /**
203  * Free transfer ring
204  *
205  * @v ring Transfer ring
206  */
207 static void uhci_ring_free ( struct uhci_ring *ring ) {
208  unsigned int i;
209 
210  /* Sanity checks */
211  assert ( uhci_ring_fill ( ring ) == 0 );
212  for ( i = 0 ; i < UHCI_RING_COUNT ; i++ )
213  assert ( ring->xfer[i] == NULL );
214 
215  /* Free queue head */
216  free_dma ( ring->head, sizeof ( *ring->head ) );
217 }
218 
219 /**
220  * Enqueue new transfer
221  *
222  * @v ring Transfer ring
223  * @v iobuf I/O buffer
224  * @v count Number of descriptors
225  * @ret rc Return status code
226  */
227 static int uhci_enqueue ( struct uhci_ring *ring, struct io_buffer *iobuf,
228  unsigned int count ) {
229  struct uhci_transfer *xfer;
230  struct uhci_transfer *end;
231  struct uhci_transfer_descriptor *desc;
232  unsigned int index = ( ring->prod % UHCI_RING_COUNT );
233  uint32_t link;
234  size_t len;
235  int rc;
236 
237  /* Sanity check */
238  assert ( count > 0 );
239  assert ( iobuf != NULL );
240 
241  /* Check for space in ring */
242  if ( ! uhci_ring_remaining ( ring ) ) {
243  rc = -ENOBUFS;
244  goto err_ring_full;
245  }
246 
247  /* Check for reachability of I/O buffer */
248  if ( ( rc = uhci_reachable ( iobuf->data, iob_len ( iobuf ) ) ) != 0 )
249  goto err_unreachable_iobuf;
250 
251  /* Allocate transfer */
252  xfer = malloc ( sizeof ( *xfer ) );
253  if ( ! xfer ) {
254  rc = -ENOMEM;
255  goto err_alloc_xfer;
256  }
257 
258  /* Initialise transfer */
259  xfer->prod = 0;
260  xfer->cons = 0;
261  xfer->len = 0;
262  xfer->iobuf = iobuf;
263 
264  /* Allocate transfer descriptors */
265  len = ( count * sizeof ( xfer->desc[0] ) );
266  xfer->desc = malloc_dma ( len, UHCI_ALIGN );
267  if ( ! xfer->desc ) {
268  rc = -ENOMEM;
269  goto err_alloc_desc;
270  }
271  if ( ( rc = uhci_reachable ( xfer->desc, len ) ) != 0 )
272  goto err_unreachable_desc;
273 
274  /* Initialise transfer descriptors */
275  memset ( xfer->desc, 0, len );
276  desc = xfer->desc;
277  for ( ; --count ; desc++ ) {
278  link = ( virt_to_phys ( desc + 1 ) | UHCI_LINK_DEPTH_FIRST );
279  desc->link = cpu_to_le32 ( link );
280  desc->flags = ring->flags;
281  }
283  desc->flags = ( ring->flags | UHCI_FL_IOC );
284 
285  /* Add to ring */
286  wmb();
287  link = virt_to_phys ( xfer->desc );
288  if ( uhci_ring_fill ( ring ) > 0 ) {
289  end = ring->end;
290  end->desc[ end->prod - 1 ].link = cpu_to_le32 ( link );
291  } else {
292  ring->head->current = cpu_to_le32 ( link );
293  }
294  assert ( ring->xfer[index] == NULL );
295  ring->xfer[index] = xfer;
296  ring->end = xfer;
297  ring->prod++;
298 
299  return 0;
300 
301  err_unreachable_desc:
302  free_dma ( xfer->desc, len );
303  err_alloc_desc:
304  free ( xfer );
305  err_alloc_xfer:
306  err_unreachable_iobuf:
307  err_ring_full:
308  return rc;
309 }
310 
311 /**
312  * Describe transfer
313  *
314  * @v ring Transfer ring
315  * @v data Data
316  * @v len Length of data
317  * @v pid Packet ID
318  */
319 static void uhci_describe ( struct uhci_ring *ring, void *data,
320  size_t len, uint8_t pid ) {
321  struct uhci_transfer *xfer = ring->end;
322  struct uhci_transfer_descriptor *desc;
323  size_t frag_len;
325 
326  do {
327  /* Calculate fragment length */
328  frag_len = len;
329  if ( frag_len > ring->mtu )
330  frag_len = ring->mtu;
331 
332  /* Populate descriptor */
333  desc = &xfer->desc[xfer->prod++];
334  if ( pid == USB_PID_IN )
335  desc->flags |= UHCI_FL_SPD;
336  control = ( ring->control | UHCI_CONTROL_PID ( pid ) |
337  UHCI_CONTROL_LEN ( frag_len ) );
338  desc->control = cpu_to_le32 ( control );
339  if ( data )
340  desc->data = virt_to_phys ( data );
341  wmb();
342  desc->status = UHCI_STATUS_ACTIVE;
343 
344  /* Update data toggle */
345  ring->control ^= UHCI_CONTROL_TOGGLE;
346 
347  /* Move to next descriptor */
348  data += frag_len;
349  len -= frag_len;
350 
351  } while ( len );
352 }
353 
354 /**
355  * Dequeue transfer
356  *
357  * @v ring Transfer ring
358  * @ret iobuf I/O buffer
359  */
360 static struct io_buffer * uhci_dequeue ( struct uhci_ring *ring ) {
361  unsigned int index = ( ring->cons % UHCI_RING_COUNT );
362  struct io_buffer *iobuf;
363  struct uhci_transfer *xfer;
364  size_t len;
365 
366  /* Sanity checks */
367  assert ( uhci_ring_fill ( ring ) > 0 );
368 
369  /* Consume transfer */
370  xfer = ring->xfer[index];
371  assert ( xfer != NULL );
372  assert ( xfer->desc != NULL );
373  iobuf = xfer->iobuf;
374  assert ( iobuf != NULL );
375  ring->xfer[index] = NULL;
376  ring->cons++;
377 
378  /* Free transfer descriptors */
379  len = ( xfer->prod * sizeof ( xfer->desc[0] ) );
380  free_dma ( xfer->desc, len );
381 
382  /* Free transfer */
383  free ( xfer );
384 
385  return iobuf;
386 }
387 
388 /**
389  * Restart ring
390  *
391  * @v ring Transfer ring
392  * @v toggle Expected data toggle for next descriptor
393  */
394 static void uhci_restart ( struct uhci_ring *ring, uint32_t toggle ) {
395  struct uhci_transfer *xfer;
396  struct uhci_transfer_descriptor *desc;
398  uint32_t link;
399  unsigned int i;
400  unsigned int j;
401 
402  /* Sanity check */
404 
405  /* If ring is empty, then just update the data toggle for the
406  * next descriptor.
407  */
408  if ( uhci_ring_fill ( ring ) == 0 ) {
409  ring->control &= ~UHCI_CONTROL_TOGGLE;
410  ring->control |= toggle;
411  return;
412  }
413 
414  /* If expected toggle does not match the toggle in the first
415  * unconsumed descriptor, then invert all toggles.
416  */
417  xfer = ring->xfer[ ring->cons % UHCI_RING_COUNT ];
418  assert ( xfer != NULL );
419  assert ( xfer->cons == 0 );
420  first = &xfer->desc[0];
421  if ( ( le32_to_cpu ( first->control ) ^ toggle ) & UHCI_CONTROL_TOGGLE){
422 
423  /* Invert toggle on all unconsumed transfer descriptors */
424  for ( i = ring->cons ; i != ring->prod ; i++ ) {
425  xfer = ring->xfer[ i % UHCI_RING_COUNT ];
426  assert ( xfer != NULL );
427  assert ( xfer->cons == 0 );
428  for ( j = 0 ; j < xfer->prod ; j++ ) {
429  desc = &xfer->desc[j];
430  desc->control ^=
432  }
433  }
434 
435  /* Invert toggle for next descriptor to be enqueued */
436  ring->control ^= UHCI_CONTROL_TOGGLE;
437  }
438 
439  /* Restart ring at first unconsumed transfer */
440  link = virt_to_phys ( first );
441  wmb();
442  ring->head->current = cpu_to_le32 ( link );
443 }
444 
445 /******************************************************************************
446  *
447  * Schedule management
448  *
449  ******************************************************************************
450  */
451 
452 /**
453  * Get link value for a queue head
454  *
455  * @v queue Queue head
456  * @ret link Link value
457  */
458 static inline uint32_t uhci_link_qh ( struct uhci_queue_head *queue ) {
459 
460  return ( virt_to_phys ( queue ) | UHCI_LINK_TYPE_QH );
461 }
462 
463 /**
464  * (Re)build asynchronous schedule
465  *
466  * @v uhci UHCI device
467  */
468 static void uhci_async_schedule ( struct uhci_device *uhci ) {
469  struct uhci_endpoint *endpoint;
470  struct uhci_queue_head *queue;
471  uint32_t end;
472  uint32_t link;
473 
474  /* Build schedule in reverse order of execution. Provided
475  * that we only ever add or remove single endpoints, this can
476  * safely run concurrently with hardware execution of the
477  * schedule.
478  */
479  link = end = uhci_link_qh ( uhci->head );
480  list_for_each_entry_reverse ( endpoint, &uhci->async, schedule ) {
481  queue = endpoint->ring.head;
482  queue->link = cpu_to_le32 ( link );
483  wmb();
484  link = uhci_link_qh ( queue );
485  }
486  if ( link == end )
488  uhci->head->link = cpu_to_le32 ( link );
489  wmb();
490 }
491 
492 /**
493  * Add endpoint to asynchronous schedule
494  *
495  * @v endpoint Endpoint
496  */
497 static void uhci_async_add ( struct uhci_endpoint *endpoint ) {
498  struct uhci_device *uhci = endpoint->uhci;
499 
500  /* Add to end of schedule */
501  list_add_tail ( &endpoint->schedule, &uhci->async );
502 
503  /* Rebuild schedule */
504  uhci_async_schedule ( uhci );
505 }
506 
507 /**
508  * Remove endpoint from asynchronous schedule
509  *
510  * @v endpoint Endpoint
511  */
512 static void uhci_async_del ( struct uhci_endpoint *endpoint ) {
513  struct uhci_device *uhci = endpoint->uhci;
514 
515  /* Remove from schedule */
516  list_check_contains_entry ( endpoint, &uhci->async, schedule );
517  list_del ( &endpoint->schedule );
518 
519  /* Rebuild schedule */
520  uhci_async_schedule ( uhci );
521 
522  /* Delay for a whole USB frame (with a 100% safety margin) */
523  mdelay ( 2 );
524 }
525 
526 /**
527  * (Re)build periodic schedule
528  *
529  * @v uhci UHCI device
530  */
531 static void uhci_periodic_schedule ( struct uhci_device *uhci ) {
532  struct uhci_endpoint *endpoint;
533  struct uhci_queue_head *queue;
534  uint32_t link;
535  uint32_t end;
536  unsigned int max_interval;
537  unsigned int i;
538 
539  /* Build schedule in reverse order of execution. Provided
540  * that we only ever add or remove single endpoints, this can
541  * safely run concurrently with hardware execution of the
542  * schedule.
543  */
544  DBGCP ( uhci, "UHCI %s periodic schedule: ", uhci->name );
545  link = end = uhci_link_qh ( uhci->head );
546  list_for_each_entry_reverse ( endpoint, &uhci->periodic, schedule ) {
547  queue = endpoint->ring.head;
548  queue->link = cpu_to_le32 ( link );
549  wmb();
550  DBGCP ( uhci, "%s%d", ( ( link == end ) ? "" : "<-" ),
551  endpoint->ep->interval );
552  link = uhci_link_qh ( queue );
553  }
554  DBGCP ( uhci, "\n" );
555 
556  /* Populate periodic frame list */
557  DBGCP ( uhci, "UHCI %s periodic frame list:", uhci->name );
558  for ( i = 0 ; i < UHCI_FRAMES ; i++ ) {
559 
560  /* Calculate maximum interval (in microframes) which
561  * may appear as part of this frame list.
562  */
563  if ( i == 0 ) {
564  /* Start of list: include all endpoints */
565  max_interval = -1U;
566  } else {
567  /* Calculate highest power-of-two frame interval */
568  max_interval = ( 1 << ( ffs ( i ) - 1 ) );
569  /* Convert to microframes */
570  max_interval <<= 3;
571  /* Round up to nearest 2^n-1 */
572  max_interval = ( ( max_interval << 1 ) - 1 );
573  }
574 
575  /* Find first endpoint in schedule satisfying this
576  * maximum interval constraint.
577  */
578  link = uhci_link_qh ( uhci->head );
579  list_for_each_entry ( endpoint, &uhci->periodic, schedule ) {
580  if ( endpoint->ep->interval <= max_interval ) {
581  queue = endpoint->ring.head;
582  link = uhci_link_qh ( queue );
583  DBGCP ( uhci, " %d:%d",
584  i, endpoint->ep->interval );
585  break;
586  }
587  }
588  uhci->frame->link[i] = cpu_to_le32 ( link );
589  }
590  wmb();
591  DBGCP ( uhci, "\n" );
592 }
593 
594 /**
595  * Add endpoint to periodic schedule
596  *
597  * @v endpoint Endpoint
598  */
599 static void uhci_periodic_add ( struct uhci_endpoint *endpoint ) {
600  struct uhci_device *uhci = endpoint->uhci;
601  struct uhci_endpoint *before;
602  unsigned int interval = endpoint->ep->interval;
603 
604  /* Find first endpoint with a smaller interval */
605  list_for_each_entry ( before, &uhci->periodic, schedule ) {
606  if ( before->ep->interval < interval )
607  break;
608  }
609  list_add_tail ( &endpoint->schedule, &before->schedule );
610 
611  /* Rebuild schedule */
613 }
614 
615 /**
616  * Remove endpoint from periodic schedule
617  *
618  * @v endpoint Endpoint
619  */
620 static void uhci_periodic_del ( struct uhci_endpoint *endpoint ) {
621  struct uhci_device *uhci = endpoint->uhci;
622 
623  /* Remove from schedule */
624  list_check_contains_entry ( endpoint, &uhci->periodic, schedule );
625  list_del ( &endpoint->schedule );
626 
627  /* Rebuild schedule */
628  uhci_periodic_schedule ( uhci );
629 
630  /* Delay for a whole USB frame (with a 100% safety margin) */
631  mdelay ( 2 );
632 }
633 
634 /**
635  * Add endpoint to appropriate schedule
636  *
637  * @v endpoint Endpoint
638  */
639 static void uhci_schedule_add ( struct uhci_endpoint *endpoint ) {
640  struct usb_endpoint *ep = endpoint->ep;
641  unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
642 
644  uhci_periodic_add ( endpoint );
645  } else {
646  uhci_async_add ( endpoint );
647  }
648 }
649 
650 /**
651  * Remove endpoint from appropriate schedule
652  *
653  * @v endpoint Endpoint
654  */
655 static void uhci_schedule_del ( struct uhci_endpoint *endpoint ) {
656  struct usb_endpoint *ep = endpoint->ep;
657  unsigned int attr = ( ep->attributes & USB_ENDPOINT_ATTR_TYPE_MASK );
658 
660  uhci_periodic_del ( endpoint );
661  } else {
662  uhci_async_del ( endpoint );
663  }
664 }
665 
666 /******************************************************************************
667  *
668  * Endpoint operations
669  *
670  ******************************************************************************
671  */
672 
673 /**
674  * Open endpoint
675  *
676  * @v ep USB endpoint
677  * @ret rc Return status code
678  */
679 static int uhci_endpoint_open ( struct usb_endpoint *ep ) {
680  struct usb_device *usb = ep->usb;
681  struct uhci_device *uhci = usb_get_hostdata ( usb );
682  struct uhci_endpoint *endpoint;
683  int rc;
684 
685  /* Allocate and initialise structure */
686  endpoint = zalloc ( sizeof ( *endpoint ) );
687  if ( ! endpoint ) {
688  rc = -ENOMEM;
689  goto err_alloc;
690  }
691  endpoint->uhci = uhci;
692  endpoint->ep = ep;
693  usb_endpoint_set_hostdata ( ep, endpoint );
694 
695  /* Initialise descriptor ring */
696  if ( ( rc = uhci_ring_alloc ( &endpoint->ring ) ) != 0 )
697  goto err_ring_alloc;
698  endpoint->ring.mtu = ep->mtu;
699  endpoint->ring.flags = UHCI_FL_CERR_MAX;
700  if ( usb->speed < USB_SPEED_FULL )
701  endpoint->ring.flags |= UHCI_FL_LS;
702  endpoint->ring.control = ( UHCI_CONTROL_DEVICE ( usb->address ) |
704 
705  /* Add to list of endpoints */
706  list_add_tail ( &endpoint->list, &uhci->endpoints );
707 
708  /* Add to schedule */
709  uhci_schedule_add ( endpoint );
710 
711  return 0;
712 
713  uhci_ring_free ( &endpoint->ring );
714  err_ring_alloc:
715  free ( endpoint );
716  err_alloc:
717  return rc;
718 }
719 
720 /**
721  * Close endpoint
722  *
723  * @v ep USB endpoint
724  */
725 static void uhci_endpoint_close ( struct usb_endpoint *ep ) {
726  struct uhci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
727  struct io_buffer *iobuf;
728 
729  /* Remove from schedule */
730  uhci_schedule_del ( endpoint );
731 
732  /* Cancel any incomplete transfers */
733  while ( uhci_ring_fill ( &endpoint->ring ) ) {
734  iobuf = uhci_dequeue ( &endpoint->ring );
735  if ( iobuf )
736  usb_complete_err ( ep, iobuf, -ECANCELED );
737  }
738 
739  /* Remove from list of endpoints */
740  list_del ( &endpoint->list );
741 
742  /* Free descriptor ring */
743  uhci_ring_free ( &endpoint->ring );
744 
745  /* Free endpoint */
746  free ( endpoint );
747 }
748 
749 /**
750  * Reset endpoint
751  *
752  * @v ep USB endpoint
753  * @ret rc Return status code
754  */
755 static int uhci_endpoint_reset ( struct usb_endpoint *ep ) {
756  struct uhci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
757  struct uhci_ring *ring = &endpoint->ring;
758 
759  /* Restart ring */
760  uhci_restart ( ring, 0 );
761 
762  return 0;
763 }
764 
765 /**
766  * Update MTU
767  *
768  * @v ep USB endpoint
769  * @ret rc Return status code
770  */
771 static int uhci_endpoint_mtu ( struct usb_endpoint *ep ) {
772  struct uhci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
773 
774  /* Update endpoint MTU */
775  endpoint->ring.mtu = ep->mtu;
776 
777  return 0;
778 }
779 
780 /**
781  * Enqueue message transfer
782  *
783  * @v ep USB endpoint
784  * @v iobuf I/O buffer
785  * @ret rc Return status code
786  */
787 static int uhci_endpoint_message ( struct usb_endpoint *ep,
788  struct io_buffer *iobuf ) {
789  struct uhci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
790  struct uhci_ring *ring = &endpoint->ring;
791  struct usb_setup_packet *packet;
792  unsigned int count;
793  size_t len;
794  int input;
795  int rc;
796 
797  /* Calculate number of descriptors */
798  assert ( iob_len ( iobuf ) >= sizeof ( *packet ) );
799  len = ( iob_len ( iobuf ) - sizeof ( *packet ) );
800  count = ( 1 /* setup stage */ +
801  ( ( len + ring->mtu - 1 ) / ring->mtu ) /* data stage */ +
802  1 /* status stage */ );
803 
804  /* Enqueue transfer */
805  if ( ( rc = uhci_enqueue ( ring, iobuf, count ) ) != 0 )
806  return rc;
807 
808  /* Describe setup stage */
809  packet = iobuf->data;
810  ring->control &= ~UHCI_CONTROL_TOGGLE;
811  uhci_describe ( ring, packet, sizeof ( *packet ), USB_PID_SETUP );
812  iob_pull ( iobuf, sizeof ( *packet ) );
813 
814  /* Describe data stage, if applicable */
815  assert ( ring->control & UHCI_CONTROL_TOGGLE );
816  input = ( packet->request & cpu_to_le16 ( USB_DIR_IN ) );
817  if ( len ) {
818  uhci_describe ( ring, iobuf->data, len,
819  ( input ? USB_PID_IN : USB_PID_OUT ) );
820  }
821 
822  /* Describe status stage */
823  ring->control |= UHCI_CONTROL_TOGGLE;
824  uhci_describe ( ring, NULL, 0,
825  ( ( len && input ) ? USB_PID_OUT : USB_PID_IN ) );
826 
827  /* Sanity check */
828  assert ( ring->end->prod == count );
829 
830  return 0;
831 }
832 
833 /**
834  * Enqueue stream transfer
835  *
836  * @v ep USB endpoint
837  * @v iobuf I/O buffer
838  * @v zlp Append a zero-length packet
839  * @ret rc Return status code
840  */
841 static int uhci_endpoint_stream ( struct usb_endpoint *ep,
842  struct io_buffer *iobuf, int zlp ) {
843  struct uhci_endpoint *endpoint = usb_endpoint_get_hostdata ( ep );
844  struct uhci_ring *ring = &endpoint->ring;
845  unsigned int count;
846  size_t len;
847  int input;
848  int rc;
849 
850  /* Calculate number of descriptors */
851  len = iob_len ( iobuf );
852  count = ( ( ( len + ring->mtu - 1 ) / ring->mtu ) + ( zlp ? 1 : 0 ) );
853 
854  /* Enqueue transfer */
855  if ( ( rc = uhci_enqueue ( ring, iobuf, count ) ) != 0 )
856  return rc;
857 
858  /* Describe data packet */
859  input = ( ep->address & USB_DIR_IN );
860  uhci_describe ( ring, iobuf->data, len,
861  ( input ? USB_PID_IN : USB_PID_OUT ) );
862 
863  /* Describe zero-length packet, if applicable */
864  if ( zlp )
865  uhci_describe ( ring, NULL, 0, USB_PID_OUT );
866 
867  /* Sanity check */
868  assert ( ring->end->prod == count );
869 
870  return 0;
871 }
872 
873 /**
874  * Check if transfer is a message transfer
875  *
876  * @v xfer UHCI transfer
877  * @ret is_message Transfer is a message transfer
878  */
879 static inline int uhci_is_message ( struct uhci_transfer *xfer ) {
880  struct uhci_transfer_descriptor *desc = &xfer->desc[0];
881 
882  return ( ( desc->control & cpu_to_le32 ( UHCI_CONTROL_PID_MASK ) ) ==
884 }
885 
886 /**
887  * Poll for completions
888  *
889  * @v endpoint Endpoint
890  */
891 static void uhci_endpoint_poll ( struct uhci_endpoint *endpoint ) {
892  struct uhci_ring *ring = &endpoint->ring;
893  struct uhci_device *uhci = endpoint->uhci;
894  struct usb_endpoint *ep = endpoint->ep;
895  struct usb_device *usb = ep->usb;
896  struct uhci_transfer *xfer;
897  struct uhci_transfer_descriptor *desc;
898  struct io_buffer *iobuf;
899  unsigned int index;
900  uint32_t link;
901  uint32_t toggle;
903  uint16_t actual;
904  size_t len;
905 
906  /* Consume all completed descriptors */
907  while ( uhci_ring_fill ( ring ) ) {
908 
909  /* Stop if we reach an uncompleted descriptor */
910  index = ( ring->cons % UHCI_RING_COUNT );
911  xfer = ring->xfer[index];
912  assert ( xfer != NULL );
913  assert ( xfer->cons < xfer->prod );
914  desc = &xfer->desc[xfer->cons];
915  rmb();
916  if ( desc->status & UHCI_STATUS_ACTIVE )
917  break;
918  control = le32_to_cpu ( desc->control );
919  actual = le16_to_cpu ( desc->actual );
920 
921  /* Update data length, if applicable */
922  if ( UHCI_DATA_PACKET ( control ) )
923  xfer->len += UHCI_ACTUAL_LEN ( actual );
924 
925  /* If we have encountered an error, then deactivate
926  * the queue head (to prevent further hardware
927  * accesses to this transfer), consume the transfer,
928  * and report the error to the USB core.
929  */
930  if ( desc->status & UHCI_STATUS_STALLED ) {
931  DBGC ( uhci, "UHCI %s %s completion %d.%d failed "
932  "(status %02x)\n", usb->name,
933  usb_endpoint_name ( ep ), index,
934  xfer->cons, desc->status );
936  ring->head->current = cpu_to_le32 ( link );
937  wmb();
938  iobuf = uhci_dequeue ( ring );
939  usb_complete_err ( ep, iobuf, -EIO );
940  break;
941  }
942 
943  /* Consume this descriptor */
944  xfer->cons++;
945 
946  /* Check for short packets */
947  if ( UHCI_SHORT_PACKET ( control, actual ) ) {
948 
949  /* Sanity checks */
950  assert ( desc->flags & UHCI_FL_SPD );
951  link = virt_to_phys ( desc );
952  assert ( ( le32_to_cpu ( ring->head->current ) &
953  ~( UHCI_ALIGN - 1 ) ) == link );
954 
955  /* If this is a message transfer, then restart
956  * at the status stage.
957  */
958  if ( uhci_is_message ( xfer ) ) {
959  xfer->cons = ( xfer->prod - 1 );
960  link = virt_to_phys ( &xfer->desc[xfer->cons] );
961  ring->head->current = cpu_to_le32 ( link );
962  break;
963  }
964 
965  /* Otherwise, this is a stream transfer.
966  * First, prevent further hardware access to
967  * this transfer.
968  */
970  ring->head->current = cpu_to_le32 ( link );
971  wmb();
972 
973  /* Determine expected data toggle for next descriptor */
974  toggle = ( ( control ^ UHCI_CONTROL_TOGGLE ) &
976 
977  /* Consume this transfer */
978  len = xfer->len;
979  iobuf = uhci_dequeue ( ring );
980 
981  /* Update packet length */
982  assert ( len <= iob_len ( iobuf ) );
983  iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
984 
985  /* Restart ring */
986  uhci_restart ( ring, toggle );
987 
988  } else if ( xfer->cons == xfer->prod ) {
989 
990  /* Completed a transfer: consume it */
991  len = xfer->len;
992  iobuf = uhci_dequeue ( ring );
993  assert ( len == iob_len ( iobuf ) );
994 
995  } else {
996 
997  /* Not a short packet and not yet complete:
998  * continue processing.
999  */
1000  continue;
1001  }
1002 
1003  /* Report completion to USB core */
1004  usb_complete ( ep, iobuf );
1005  }
1006 }
1007 
1008 /******************************************************************************
1009  *
1010  * Device operations
1011  *
1012  ******************************************************************************
1013  */
1014 
1015 /**
1016  * Open device
1017  *
1018  * @v usb USB device
1019  * @ret rc Return status code
1020  */
1021 static int uhci_device_open ( struct usb_device *usb ) {
1022  struct uhci_device *uhci = usb_bus_get_hostdata ( usb->port->hub->bus );
1023 
1024  usb_set_hostdata ( usb, uhci );
1025  return 0;
1026 }
1027 
1028 /**
1029  * Close device
1030  *
1031  * @v usb USB device
1032  */
1033 static void uhci_device_close ( struct usb_device *usb ) {
1034  struct uhci_device *uhci = usb_get_hostdata ( usb );
1035  struct usb_bus *bus = uhci->bus;
1036 
1037  /* Free device address, if assigned */
1038  if ( usb->address )
1039  usb_free_address ( bus, usb->address );
1040 }
1041 
1042 /**
1043  * Assign device address
1044  *
1045  * @v usb USB device
1046  * @ret rc Return status code
1047  */
1048 static int uhci_device_address ( struct usb_device *usb ) {
1049  struct uhci_device *uhci = usb_get_hostdata ( usb );
1050  struct usb_bus *bus = uhci->bus;
1051  struct usb_endpoint *ep0 = usb_endpoint ( usb, USB_EP0_ADDRESS );
1052  struct uhci_endpoint *endpoint0 = usb_endpoint_get_hostdata ( ep0 );
1053  int address;
1054  int rc;
1055 
1056  /* Sanity checks */
1057  assert ( usb->address == 0 );
1058  assert ( ep0 != NULL );
1059 
1060  /* Allocate device address */
1062  if ( address < 0 ) {
1063  rc = address;
1064  DBGC ( uhci, "UHCI %s could not allocate address: %s\n",
1065  usb->name, strerror ( rc ) );
1066  goto err_alloc_address;
1067  }
1068 
1069  /* Set address */
1070  if ( ( rc = usb_set_address ( usb, address ) ) != 0 )
1071  goto err_set_address;
1072 
1073  /* Update device address */
1074  usb->address = address;
1075  endpoint0->ring.control |= UHCI_CONTROL_DEVICE ( address );
1076 
1077  return 0;
1078 
1079  err_set_address:
1081  err_alloc_address:
1082  return rc;
1083 }
1084 
1085 /******************************************************************************
1086  *
1087  * Hub operations
1088  *
1089  ******************************************************************************
1090  */
1091 
1092 /**
1093  * Open hub
1094  *
1095  * @v hub USB hub
1096  * @ret rc Return status code
1097  */
1098 static int uhci_hub_open ( struct usb_hub *hub __unused ) {
1099 
1100  /* Nothing to do */
1101  return 0;
1102 }
1103 
1104 /**
1105  * Close hub
1106  *
1107  * @v hub USB hub
1108  */
1109 static void uhci_hub_close ( struct usb_hub *hub __unused ) {
1110 
1111  /* Nothing to do */
1112 }
1113 
1114 /******************************************************************************
1115  *
1116  * Root hub operations
1117  *
1118  ******************************************************************************
1119  */
1120 
1121 /**
1122  * Open root hub
1123  *
1124  * @v hub USB hub
1125  * @ret rc Return status code
1126  */
1127 static int uhci_root_open ( struct usb_hub *hub ) {
1128  struct usb_bus *bus = hub->bus;
1129  struct uhci_device *uhci = usb_bus_get_hostdata ( bus );
1130 
1131  /* Record hub driver private data */
1132  usb_hub_set_drvdata ( hub, uhci );
1133 
1134  return 0;
1135 }
1136 
1137 /**
1138  * Close root hub
1139  *
1140  * @v hub USB hub
1141  */
1142 static void uhci_root_close ( struct usb_hub *hub ) {
1143 
1144  /* Clear hub driver private data */
1145  usb_hub_set_drvdata ( hub, NULL );
1146 }
1147 
1148 /**
1149  * Enable port
1150  *
1151  * @v hub USB hub
1152  * @v port USB port
1153  * @ret rc Return status code
1154  */
1155 static int uhci_root_enable ( struct usb_hub *hub, struct usb_port *port ) {
1156  struct uhci_device *uhci = usb_hub_get_drvdata ( hub );
1157  uint16_t portsc;
1158  unsigned int i;
1159 
1160  /* Reset port */
1161  portsc = inw ( uhci->regs + UHCI_PORTSC ( port->address ) );
1162  portsc |= UHCI_PORTSC_PR;
1163  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1165  portsc &= ~UHCI_PORTSC_PR;
1166  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1168 
1169  /* Enable port */
1170  portsc |= UHCI_PORTSC_PED;
1171  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1173 
1174  /* Wait for port to become enabled */
1175  for ( i = 0 ; i < UHCI_PORT_ENABLE_MAX_WAIT_MS ; i++ ) {
1176 
1177  /* Check port status */
1178  portsc = inw ( uhci->regs + UHCI_PORTSC ( port->address ) );
1179  if ( portsc & UHCI_PORTSC_PED )
1180  return 0;
1181 
1182  /* Delay */
1183  mdelay ( 1 );
1184  }
1185 
1186  DBGC ( uhci, "UHCI %s-%d timed out waiting for port to enable "
1187  "(status %04x)\n", uhci->name, port->address, portsc );
1188  return -ETIMEDOUT;
1189 }
1190 
1191 /**
1192  * Disable port
1193  *
1194  * @v hub USB hub
1195  * @v port USB port
1196  * @ret rc Return status code
1197  */
1198 static int uhci_root_disable ( struct usb_hub *hub, struct usb_port *port ) {
1199  struct uhci_device *uhci = usb_hub_get_drvdata ( hub );
1200  uint16_t portsc;
1201 
1202  /* Disable port */
1203  portsc = inw ( uhci->regs + UHCI_PORTSC ( port->address ) );
1204  portsc &= ~UHCI_PORTSC_PED;
1205  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1206 
1207  return 0;
1208 }
1209 
1210 /**
1211  * Update root hub port speed
1212  *
1213  * @v hub USB hub
1214  * @v port USB port
1215  * @ret rc Return status code
1216  */
1217 static int uhci_root_speed ( struct usb_hub *hub, struct usb_port *port ) {
1218  struct uhci_device *uhci = usb_hub_get_drvdata ( hub );
1219  struct pci_device pci;
1220  uint16_t portsc;
1221  unsigned int speed;
1222 
1223  /* Read port status */
1224  portsc = inw ( uhci->regs + UHCI_PORTSC ( port->address ) );
1225  if ( ! ( portsc & UHCI_PORTSC_CCS ) ) {
1226  /* Port not connected */
1227  speed = USB_SPEED_NONE;
1228  } else if ( uhci->companion &&
1230  uhci->companion ) ) {
1231  /* Defer connection detection until companion
1232  * controller has been enumerated.
1233  */
1234  pci_init ( &pci, uhci->companion );
1235  DBGC ( uhci, "UHCI %s-%d deferring for companion " PCI_FMT "\n",
1236  uhci->name, port->address, PCI_ARGS ( &pci ) );
1237  speed = USB_SPEED_NONE;
1238  } else if ( portsc & UHCI_PORTSC_LS ) {
1239  /* Low-speed device */
1240  speed = USB_SPEED_LOW;
1241  } else {
1242  /* Full-speed device */
1243  speed = USB_SPEED_FULL;
1244  }
1245  port->speed = speed;
1246 
1247  /* Record disconnections and clear changes */
1248  port->disconnected |= ( portsc & UHCI_PORTSC_CSC );
1249  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1250 
1251  return 0;
1252 }
1253 
1254 /**
1255  * Clear transaction translator buffer
1256  *
1257  * @v hub USB hub
1258  * @v port USB port
1259  * @v ep USB endpoint
1260  * @ret rc Return status code
1261  */
1262 static int uhci_root_clear_tt ( struct usb_hub *hub, struct usb_port *port,
1263  struct usb_endpoint *ep ) {
1264  struct uhci_device *uhci = usb_hub_get_drvdata ( hub );
1265 
1266  /* Should never be called; this is a root hub */
1267  DBGC ( uhci, "UHCI %s-%d nonsensical CLEAR_TT for %s %s\n", uhci->name,
1268  port->address, ep->usb->name, usb_endpoint_name ( ep ) );
1269 
1270  return -ENOTSUP;
1271 }
1272 
1273 /**
1274  * Poll for port status changes
1275  *
1276  * @v hub USB hub
1277  * @v port USB port
1278  */
1279 static void uhci_root_poll ( struct usb_hub *hub, struct usb_port *port ) {
1280  struct uhci_device *uhci = usb_hub_get_drvdata ( hub );
1281  uint16_t portsc;
1282  uint16_t change;
1283 
1284  /* Do nothing unless something has changed */
1285  portsc = inw ( uhci->regs + UHCI_PORTSC ( port->address ) );
1286  change = ( portsc & UHCI_PORTSC_CHANGE );
1287  if ( ! change )
1288  return;
1289 
1290  /* Record disconnections and clear changes */
1291  port->disconnected |= ( portsc & UHCI_PORTSC_CSC );
1292  outw ( portsc, uhci->regs + UHCI_PORTSC ( port->address ) );
1293 
1294  /* Report port status change */
1295  usb_port_changed ( port );
1296 }
1297 
1298 /******************************************************************************
1299  *
1300  * Bus operations
1301  *
1302  ******************************************************************************
1303  */
1304 
1305 /**
1306  * Open USB bus
1307  *
1308  * @v bus USB bus
1309  * @ret rc Return status code
1310  */
1311 static int uhci_bus_open ( struct usb_bus *bus ) {
1312  struct uhci_device *uhci = usb_bus_get_hostdata ( bus );
1313  int rc;
1314 
1315  /* Sanity checks */
1316  assert ( list_empty ( &uhci->async ) );
1317  assert ( list_empty ( &uhci->periodic ) );
1318 
1319  /* Allocate and initialise asynchronous queue head */
1320  uhci->head = malloc_dma ( sizeof ( *uhci->head ), UHCI_ALIGN );
1321  if ( ! uhci->head ) {
1322  rc = -ENOMEM;
1323  goto err_alloc_head;
1324  }
1325  if ( ( rc = uhci_reachable ( uhci->head, sizeof ( *uhci->head ) ) ) !=0)
1326  goto err_unreachable_head;
1327  memset ( uhci->head, 0, sizeof ( *uhci->head ) );
1329  uhci_async_schedule ( uhci );
1330 
1331  /* Allocate periodic frame list */
1332  uhci->frame = malloc_dma ( sizeof ( *uhci->frame ),
1333  sizeof ( *uhci->frame ) );
1334  if ( ! uhci->frame ) {
1335  rc = -ENOMEM;
1336  goto err_alloc_frame;
1337  }
1338  if ( ( rc = uhci_reachable ( uhci->frame,
1339  sizeof ( *uhci->frame ) ) ) != 0 )
1340  goto err_unreachable_frame;
1341  uhci_periodic_schedule ( uhci );
1342  outl ( virt_to_phys ( uhci->frame ), uhci->regs + UHCI_FLBASEADD );
1343 
1344  /* Start controller */
1345  uhci_run ( uhci );
1346 
1347  return 0;
1348 
1349  uhci_stop ( uhci );
1350  err_unreachable_frame:
1351  free_dma ( uhci->frame, sizeof ( *uhci->frame ) );
1352  err_alloc_frame:
1353  err_unreachable_head:
1354  free_dma ( uhci->head, sizeof ( *uhci->head ) );
1355  err_alloc_head:
1356  return rc;
1357 }
1358 
1359 /**
1360  * Close USB bus
1361  *
1362  * @v bus USB bus
1363  */
1364 static void uhci_bus_close ( struct usb_bus *bus ) {
1365  struct uhci_device *uhci = usb_bus_get_hostdata ( bus );
1366 
1367  /* Sanity checks */
1368  assert ( list_empty ( &uhci->async ) );
1369  assert ( list_empty ( &uhci->periodic ) );
1370 
1371  /* Stop controller */
1372  uhci_stop ( uhci );
1373 
1374  /* Free periodic frame list */
1375  free_dma ( uhci->frame, sizeof ( *uhci->frame ) );
1376 
1377  /* Free asynchronous schedule */
1378  free_dma ( uhci->head, sizeof ( *uhci->head ) );
1379 }
1380 
1381 /**
1382  * Poll USB bus
1383  *
1384  * @v bus USB bus
1385  */
1386 static void uhci_bus_poll ( struct usb_bus *bus ) {
1387  struct uhci_device *uhci = usb_bus_get_hostdata ( bus );
1388  struct usb_hub *hub = bus->hub;
1389  struct uhci_endpoint *endpoint;
1390  unsigned int i;
1391 
1392  /* UHCI defers interrupts (including short packet detection)
1393  * until the end of the frame. This can result in bulk IN
1394  * endpoints remaining halted for much of the time, waiting
1395  * for software action to reset the data toggles. We
1396  * therefore ignore USBSTS and unconditionally poll all
1397  * endpoints for completed transfer descriptors.
1398  *
1399  * As with EHCI, we trust that completion handlers are minimal
1400  * and will not do anything that could plausibly affect the
1401  * endpoint list itself.
1402  */
1403  list_for_each_entry ( endpoint, &uhci->endpoints, list )
1404  uhci_endpoint_poll ( endpoint );
1405 
1406  /* UHCI provides no single bit to indicate that a port status
1407  * change has occurred. We therefore unconditionally iterate
1408  * over all ports looking for status changes.
1409  */
1410  for ( i = 1 ; i <= UHCI_PORTS ; i++ )
1411  uhci_root_poll ( hub, usb_port ( hub, i ) );
1412 }
1413 
1414 /******************************************************************************
1415  *
1416  * PCI interface
1417  *
1418  ******************************************************************************
1419  */
1420 
1421 /** USB host controller operations */
1423  .endpoint = {
1425  .close = uhci_endpoint_close,
1426  .reset = uhci_endpoint_reset,
1427  .mtu = uhci_endpoint_mtu,
1428  .message = uhci_endpoint_message,
1429  .stream = uhci_endpoint_stream,
1430  },
1431  .device = {
1432  .open = uhci_device_open,
1433  .close = uhci_device_close,
1434  .address = uhci_device_address,
1435  },
1436  .bus = {
1437  .open = uhci_bus_open,
1438  .close = uhci_bus_close,
1439  .poll = uhci_bus_poll,
1440  },
1441  .hub = {
1442  .open = uhci_hub_open,
1443  .close = uhci_hub_close,
1444  },
1445  .root = {
1446  .open = uhci_root_open,
1447  .close = uhci_root_close,
1448  .enable = uhci_root_enable,
1449  .disable = uhci_root_disable,
1450  .speed = uhci_root_speed,
1451  .clear_tt = uhci_root_clear_tt,
1452  },
1453 };
1454 
1455 /**
1456  * Locate EHCI companion controller (when no EHCI support is present)
1457  *
1458  * @v pci PCI device
1459  * @ret busdevfn EHCI companion controller bus:dev.fn (if any)
1460  */
1461 __weak unsigned int ehci_companion ( struct pci_device *pci __unused ) {
1462  return 0;
1463 }
1464 
1465 /**
1466  * Probe PCI device
1467  *
1468  * @v pci PCI device
1469  * @ret rc Return status code
1470  */
1471 static int uhci_probe ( struct pci_device *pci ) {
1472  struct uhci_device *uhci;
1473  struct usb_port *port;
1474  unsigned int i;
1475  int rc;
1476 
1477  /* Allocate and initialise structure */
1478  uhci = zalloc ( sizeof ( *uhci ) );
1479  if ( ! uhci ) {
1480  rc = -ENOMEM;
1481  goto err_alloc;
1482  }
1483  uhci->name = pci->dev.name;
1484  INIT_LIST_HEAD ( &uhci->endpoints );
1485  INIT_LIST_HEAD ( &uhci->async );
1486  INIT_LIST_HEAD ( &uhci->periodic );
1487 
1488  /* Fix up PCI device */
1489  adjust_pci_device ( pci );
1490 
1491  /* Identify EHCI companion controller, if any */
1492  uhci->companion = ehci_companion ( pci );
1493 
1494  /* Claim ownership from BIOS. (There is no release mechanism
1495  * for UHCI.)
1496  */
1498 
1499  /* Map registers */
1500  uhci->regs = pci->ioaddr;
1501  if ( ! uhci->regs ) {
1502  rc = -ENODEV;
1503  goto err_ioremap;
1504  }
1505 
1506  /* Reset device */
1507  if ( ( rc = uhci_reset ( uhci ) ) != 0 )
1508  goto err_reset;
1509 
1510  /* Allocate USB bus */
1511  uhci->bus = alloc_usb_bus ( &pci->dev, UHCI_PORTS, UHCI_MTU,
1512  &uhci_operations );
1513  if ( ! uhci->bus ) {
1514  rc = -ENOMEM;
1515  goto err_alloc_bus;
1516  }
1517  usb_bus_set_hostdata ( uhci->bus, uhci );
1518  usb_hub_set_drvdata ( uhci->bus->hub, uhci );
1519 
1520  /* Set port protocols */
1521  for ( i = 1 ; i <= UHCI_PORTS ; i++ ) {
1522  port = usb_port ( uhci->bus->hub, i );
1523  port->protocol = USB_PROTO_2_0;
1524  }
1525 
1526  /* Register USB bus */
1527  if ( ( rc = register_usb_bus ( uhci->bus ) ) != 0 )
1528  goto err_register;
1529 
1530  pci_set_drvdata ( pci, uhci );
1531  return 0;
1532 
1533  unregister_usb_bus ( uhci->bus );
1534  err_register:
1535  free_usb_bus ( uhci->bus );
1536  err_alloc_bus:
1537  uhci_reset ( uhci );
1538  err_reset:
1539  err_ioremap:
1540  free ( uhci );
1541  err_alloc:
1542  return rc;
1543 }
1544 
1545 /**
1546  * Remove PCI device
1547  *
1548  * @v pci PCI device
1549  */
1550 static void uhci_remove ( struct pci_device *pci ) {
1551  struct uhci_device *uhci = pci_get_drvdata ( pci );
1552  struct usb_bus *bus = uhci->bus;
1553 
1554  unregister_usb_bus ( bus );
1555  assert ( list_empty ( &uhci->async ) );
1556  assert ( list_empty ( &uhci->periodic ) );
1557  free_usb_bus ( bus );
1558  uhci_reset ( uhci );
1559  free ( uhci );
1560 }
1561 
1562 /** UHCI PCI device IDs */
1563 static struct pci_device_id uhci_ids[] = {
1564  PCI_ROM ( 0xffff, 0xffff, "uhci", "UHCI", 0 ),
1565 };
1566 
1567 /** UHCI PCI driver */
1568 struct pci_driver uhci_driver __pci_driver = {
1569  .ids = uhci_ids,
1570  .id_count = ( sizeof ( uhci_ids ) / sizeof ( uhci_ids[0] ) ),
1573  .probe = uhci_probe,
1574  .remove = uhci_remove,
1575 };
#define UHCI_USBCMD_HCRESET
Host controller reset.
Definition: uhci.h:39
#define iob_pull(iobuf, len)
Definition: iobuf.h:98
unsigned int cons
Consumer counter.
Definition: uhci.h:235
#define __attribute__(x)
Definition: compiler.h:10
#define UHCI_PORTSC_PED
Port enabled.
Definition: uhci.h:69
static int uhci_device_open(struct usb_device *usb)
Open device.
Definition: uhci.c:1021
static void usb_endpoint_set_hostdata(struct usb_endpoint *ep, void *priv)
Set USB endpoint host controller private data.
Definition: usb.h:561
unsigned int prod
Producer counter.
Definition: uhci.h:211
#define PCI_CLASS_ID(base, sub, progif)
Construct PCI class ID.
Definition: pci.h:179
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
unsigned short uint16_t
Definition: stdint.h:11
A queue head.
Definition: uhci.h:192
wmb()
#define UHCI_FL_CERR_MAX
Error counter maximum value.
Definition: uhci.h:148
uint16_t inw(volatile uint16_t *io_addr)
Read 16-bit word from I/O-mapped device.
#define UHCI_FL_IOC
Interrupt on completion.
Definition: uhci.h:154
static void uhci_run(struct uhci_device *uhci)
Start UHCI device.
Definition: uhci.c:83
A PCI driver.
Definition: pci.h:224
#define UHCI_CONTROL_ENDPOINT(address)
Endpoint address.
Definition: uhci.h:166
static void uhci_async_add(struct uhci_endpoint *endpoint)
Add endpoint to asynchronous schedule.
Definition: uhci.c:497
USB Universal Host Controller Interface (UHCI) driver.
struct uhci_frame_list * frame
Frame list.
Definition: uhci.h:319
A USB hub.
Definition: usb.h:824
static int uhci_endpoint_mtu(struct usb_endpoint *ep)
Update MTU.
Definition: uhci.c:771
static void uhci_periodic_del(struct uhci_endpoint *endpoint)
Remove endpoint from periodic schedule.
Definition: uhci.c:620
static void uhci_restart(struct uhci_ring *ring, uint32_t toggle)
Restart ring.
Definition: uhci.c:394
struct uhci_queue_head * head
Asynchronous queue head.
Definition: uhci.h:317
#define le32_to_cpu(value)
Definition: byteswap.h:113
uint32_t link
Link pointer.
Definition: uhci.h:101
struct usb_bus * find_usb_bus_by_location(unsigned int bus_type, unsigned int location)
Find USB bus by device location.
Definition: usb.c:2152
#define outw(data, io_addr)
Definition: io.h:319
#define UHCI_STATUS_ACTIVE
Active.
Definition: uhci.h:121
unsigned long ioaddr
I/O address.
Definition: pci.h:200
struct usb_bus * alloc_usb_bus(struct device *dev, unsigned int ports, size_t mtu, struct usb_host_operations *op)
Allocate USB bus.
Definition: usb.c:2031
Error codes.
Low speed (1.5Mbps)
Definition: usb.h:48
#define USB_RESET_RECOVER_DELAY_MS
Reset recovery time.
Definition: usb.h:1291
struct list_head async
Asynchronous schedule.
Definition: uhci.h:324
#define USB_ENDPOINT_ATTR_TYPE_MASK
Endpoint attribute transfer type mask.
Definition: usb.h:266
static unsigned int uhci_ring_fill(struct uhci_ring *ring)
Calculate space used in transfer ring.
Definition: uhci.h:267
USB 2.0.
Definition: usb.h:22
#define UHCI_RING_COUNT
Number of transfer descriptors in a ring.
Definition: uhci.h:228
__weak unsigned int ehci_companion(struct pci_device *pci __unused)
Locate EHCI companion controller (when no EHCI support is present)
Definition: uhci.c:1461
OUT PID.
Definition: usb.h:62
struct uhci_device * uhci
UHCI device.
Definition: uhci.h:338
struct pci_device_id * ids
PCI ID table.
Definition: pci.h:226
uint64_t address
Base address.
Definition: ena.h:24
static void usb_set_hostdata(struct usb_device *usb, void *priv)
Set USB device host controller private data.
Definition: usb.h:767
int pci_write_config_word(struct pci_device *pci, unsigned int where, uint16_t value)
Write 16-bit word to PCI configuration space.
uint8_t attr
Type and attributes.
Definition: librm.h:256
#define UHCI_PORTSC(port)
Port status and control register.
Definition: uhci.h:57
A UHCI endpoint.
Definition: uhci.h:336
#define DBGC(...)
Definition: compiler.h:505
#define UHCI_USBCMD_RUN
Run/stop.
Definition: uhci.h:42
#define USB_RESET_DELAY_MS
Minimum reset time.
Definition: usb.h:1284
#define UHCI_USBSTS
USB status register.
Definition: uhci.h:45
char name[40]
Name.
Definition: device.h:75
static unsigned int uhci_ring_remaining(struct uhci_ring *ring)
Calculate space remaining in transfer ring.
Definition: uhci.h:282
static void uhci_async_del(struct uhci_endpoint *endpoint)
Remove endpoint from asynchronous schedule.
Definition: uhci.c:512
static int uhci_endpoint_message(struct usb_endpoint *ep, struct io_buffer *iobuf)
Enqueue message transfer.
Definition: uhci.c:787
#define UHCI_MTU
Maximum transfer size.
Definition: uhci.h:27
#define UHCI_PORTSC_CSC
Connect status change.
Definition: uhci.h:72
uint32_t control
Control.
Definition: uhci.h:109
uint8_t flags
Flags.
Definition: uhci.h:107
static int uhci_root_speed(struct usb_hub *hub, struct usb_port *port)
Update root hub port speed.
Definition: uhci.c:1217
#define UHCI_CONTROL_DEVICE(address)
Device address.
Definition: uhci.h:163
uint32_t current
Current transfer descriptor.
Definition: uhci.h:196
unsigned int prod
Producer counter.
Definition: uhci.h:233
const char * name
Name.
Definition: uhci.h:311
void adjust_pci_device(struct pci_device *pci)
Enable PCI device.
Definition: pci.c:149
static __always_inline unsigned long virt_to_phys(volatile const void *addr)
Convert virtual address to a physical address.
Definition: uaccess.h:287
struct device dev
Generic device.
Definition: pci.h:189
static int uhci_enqueue(struct uhci_ring *ring, struct io_buffer *iobuf, unsigned int count)
Enqueue new transfer.
Definition: uhci.c:227
unsigned int address
Device address, if assigned.
Definition: usb.h:716
uint32_t link[UHCI_FRAMES]
Link pointer.
Definition: uhci.h:95
static void uhci_root_close(struct usb_hub *hub)
Close root hub.
Definition: uhci.c:1142
unsigned int speed
Device speed.
Definition: usb.h:712
A single UHCI transfer.
Definition: uhci.h:209
#define ECANCELED
Operation canceled.
Definition: errno.h:343
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
void usb_port_changed(struct usb_port *port)
Report port status change.
Definition: usb.c:1794
#define PCI_CLASS_SERIAL
Definition: Pci22.h:272
Dynamic memory allocation.
static int uhci_endpoint_stream(struct usb_endpoint *ep, struct io_buffer *iobuf, int zlp)
Enqueue stream transfer.
Definition: uhci.c:841
struct list_head periodic
Periodic schedule.
Definition: uhci.h:329
static void usb_bus_set_hostdata(struct usb_bus *bus, void *priv)
Set USB bus host controller private data.
Definition: usb.h:1028
#define UHCI_PORTSC_CCS
Current connect status.
Definition: uhci.h:75
#define list_empty(list)
Test whether a list is empty.
Definition: list.h:136
static int usb_set_address(struct usb_device *usb, unsigned int address)
Set address.
Definition: usb.h:1136
struct io_buffer ** iobuf
I/O buffers.
Definition: ehci.h:379
uint8_t flags
Base flags.
Definition: uhci.h:243
static int uhci_endpoint_open(struct usb_endpoint *ep)
Open endpoint.
Definition: uhci.c:679
#define list_del(list)
Delete an entry from a list.
Definition: list.h:119
#define UHCI_PORTSC_PR
Port reset.
Definition: uhci.h:60
A USB port.
Definition: usb.h:796
static void pci_set_drvdata(struct pci_device *pci, void *priv)
Set PCI driver-private data.
Definition: pci.h:338
#define rmb()
Definition: io.h:484
#define ENOMEM
Not enough space.
Definition: errno.h:534
A USB endpoint.
Definition: usb.h:389
static int uhci_device_address(struct usb_device *usb)
Assign device address.
Definition: uhci.c:1048
static void uhci_periodic_schedule(struct uhci_device *uhci)
(Re)build periodic schedule
Definition: uhci.c:531
#define UHCI_PORT_ENABLE_MAX_WAIT_MS
Maximum time to wait for a port to be enabled.
Definition: uhci.h:304
static signed char phys[4]
Definition: epic100.c:88
static void uhci_schedule_del(struct uhci_endpoint *endpoint)
Remove endpoint from appropriate schedule.
Definition: uhci.c:655
u8 port
Port number.
Definition: CIB_PRM.h:31
static struct usb_host_operations uhci_operations
USB host controller operations.
Definition: uhci.c:1422
#define BUS_TYPE_PCI
PCI bus type.
Definition: device.h:43
static int uhci_hub_open(struct usb_hub *hub __unused)
Open hub.
Definition: uhci.c:1098
void unregister_usb_bus(struct usb_bus *bus)
Unregister USB bus.
Definition: usb.c:2102
struct usb_port * port
USB port.
Definition: usb.h:710
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
static void uhci_async_schedule(struct uhci_device *uhci)
(Re)build asynchronous schedule
Definition: uhci.c:468
struct uhci_queue_head * head
Queue head.
Definition: uhci.h:257
struct uhci_ring ring
Transfer ring.
Definition: uhci.h:347
Not connected.
Definition: usb.h:46
#define UHCI_PORTSC_LS
Low-speed device attached.
Definition: uhci.h:63
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition: list.h:420
#define list_add_tail(new, head)
Add a new entry to the tail of a list.
Definition: list.h:93
static struct io_buffer * uhci_dequeue(struct uhci_ring *ring)
Dequeue transfer.
Definition: uhci.c:360
static void uhci_endpoint_close(struct usb_endpoint *ep)
Close endpoint.
Definition: uhci.c:725
unsigned int companion
EHCI companion controller bus:dev.fn address (if any)
Definition: uhci.h:314
#define list_for_each_entry_reverse(pos, head, member)
Iterate over entries in a list in reverse order.
Definition: list.h:433
#define UHCI_USBSTS_HCHALTED
Host controller halted.
Definition: uhci.h:48
uint16_t actual
Actual length.
Definition: uhci.h:103
u32 link
Link to next descriptor.
Definition: ar9003_mac.h:68
unsigned long regs
Registers.
Definition: uhci.h:309
A transfer ring.
Definition: uhci.h:231
static struct pci_device_id uhci_ids[]
UHCI PCI device IDs.
Definition: uhci.c:1563
#define USB_DIR_IN
Data transfer is from device to host.
Definition: usb.h:83
#define UHCI_STATUS_STALLED
Stalled.
Definition: uhci.h:124
char name[32]
Name.
Definition: usb.h:708
#define UHCI_USBCMD
USB command register.
Definition: uhci.h:33
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
#define cpu_to_le32(value)
Definition: byteswap.h:107
A USB device.
Definition: usb.h:706
struct list_head endpoints
List of all endpoints.
Definition: uhci.h:322
#define UHCI_CONTROL_TOGGLE
Data toggle.
Definition: uhci.h:169
static struct usb_endpoint * usb_endpoint(struct usb_device *usb, unsigned int address)
Get USB endpoint.
Definition: usb.h:789
static void uhci_hub_close(struct usb_hub *hub __unused)
Close hub.
Definition: uhci.c:1109
USB Enhanced Host Controller Interface (EHCI) driver.
#define iob_unput(iobuf, len)
Definition: iobuf.h:131
#define USB_ENDPOINT_ATTR_INTERRUPT
Interrupt endpoint transfer type.
Definition: usb.h:278
static int uhci_is_message(struct uhci_transfer *xfer)
Check if transfer is a message transfer.
Definition: uhci.c:879
#define UHCI_CONTROL_PID_MASK
Packet ID mask.
Definition: uhci.h:160
#define UHCI_RESET_MAX_WAIT_MS
Maximum time to wait for reset to complete.
Definition: uhci.h:298
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
#define UHCI_USBLEGSUP
USB legacy support register (in PCI configuration space)
Definition: uhci.h:186
SETUP PID.
Definition: usb.h:64
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
#define PCI_CLASS_SERIAL_USB
Definition: Pci22.h:278
#define PCI_FMT
PCI device debug message format.
Definition: pci.h:287
#define outl(data, io_addr)
Definition: io.h:329
PCI bus.
#define UHCI_FRAMES
Number of frames in frame list.
Definition: uhci.h:90
A PCI device.
Definition: pci.h:187
uint8_t status
Status.
Definition: uhci.h:105
static int uhci_ring_alloc(struct uhci_ring *ring)
Allocate transfer ring.
Definition: uhci.c:175
static size_t iob_len(struct io_buffer *iobuf)
Calculate length of data in an I/O buffer.
Definition: iobuf.h:151
static void uhci_endpoint_poll(struct uhci_endpoint *endpoint)
Poll for completions.
Definition: uhci.c:891
struct io_buffer * iobuf
I/O buffer.
Definition: uhci.h:221
size_t len
Completed data length.
Definition: uhci.h:215
uint32_t control
Control.
Definition: myson.h:14
void usb_free_address(struct usb_bus *bus, unsigned int address)
Free device address.
Definition: usb.c:2198
#define ENODEV
No such device.
Definition: errno.h:509
u32 addr
Definition: sky2.h:8
static int uhci_root_clear_tt(struct usb_hub *hub, struct usb_port *port, struct usb_endpoint *ep)
Clear transaction translator buffer.
Definition: uhci.c:1262
unsigned char uint8_t
Definition: stdint.h:10
#define UHCI_LINK_DEPTH_FIRST
Depth-first processing.
Definition: uhci.h:81
struct uhci_transfer * xfer[UHCI_RING_COUNT]
Transfers.
Definition: uhci.h:252
static void * usb_get_hostdata(struct usb_device *usb)
Get USB device host controller private data.
Definition: usb.h:778
struct list_head schedule
Endpoint schedule.
Definition: uhci.h:344
#define UHCI_LINK_TERMINATE
List terminator.
Definition: uhci.h:87
static int uhci_root_enable(struct usb_hub *hub, struct usb_port *port)
Enable port.
Definition: uhci.c:1155
A PCI device ID list entry.
Definition: pci.h:151
#define le16_to_cpu(value)
Definition: byteswap.h:112
unsigned int uint32_t
Definition: stdint.h:12
#define ffs(x)
Find first (i.e.
Definition: strings.h:140
void * malloc(size_t size)
Allocate memory.
Definition: malloc.c:583
A USB setup data packet.
Definition: usb.h:68
const char * usb_endpoint_name(struct usb_endpoint *ep)
Get USB endpoint name (for debugging)
Definition: usb.c:220
static void uhci_periodic_add(struct uhci_endpoint *endpoint)
Add endpoint to periodic schedule.
Definition: uhci.c:599
#define UHCI_FL_LS
Low speed device.
Definition: uhci.h:151
size_t mtu
Maximum transfer size.
Definition: usb.h:397
uint16_t request
Request.
Definition: usb.h:70
#define UHCI_PORTSC_CHANGE
Port status change mask.
Definition: uhci.h:78
struct usb_endpoint * ep
USB endpoint.
Definition: uhci.h:340
static int uhci_reset(struct uhci_device *uhci)
Reset UHCI device.
Definition: uhci.c:130
unsigned long physaddr_t
Definition: stdint.h:20
#define __unused
Declare a variable or data structure as unused.
Definition: compiler.h:573
static void * pci_get_drvdata(struct pci_device *pci)
Get PCI driver-private data.
Definition: pci.h:348
static int uhci_root_open(struct usb_hub *hub)
Open root hub.
Definition: uhci.c:1127
#define UHCI_DATA_PACKET(control)
Check for data packet.
Definition: uhci.h:179
void mdelay(unsigned long msecs)
Delay for a fixed number of milliseconds.
Definition: timer.c:78
#define INIT_LIST_HEAD(list)
Initialise a list head.
Definition: list.h:45
static void uhci_describe(struct uhci_ring *ring, void *data, size_t len, uint8_t pid)
Describe transfer.
Definition: uhci.c:319
uint32_t control
Base control word.
Definition: uhci.h:249
struct uhci_transfer * end
End of transfer ring (if non-empty)
Definition: uhci.h:254
static void * usb_bus_get_hostdata(struct usb_bus *bus)
Get USB bus host controller private data.
Definition: usb.h:1039
#define UHCI_USBLEGSUP_DEFAULT
USB legacy support default value.
Definition: uhci.h:189
uint32_t len
Length.
Definition: ena.h:14
#define UHCI_STOP_MAX_WAIT_MS
Maximum time to wait for host controller to stop.
Definition: uhci.h:292
#define ENOBUFS
No buffer space available.
Definition: errno.h:498
Universal Serial Bus (USB)
int register_usb_bus(struct usb_bus *bus)
Register USB bus.
Definition: usb.c:2067
#define UHCI_SHORT_PACKET(control, actual)
Check for short packet.
Definition: uhci.h:182
A UHCI device.
Definition: uhci.h:307
static void usb_complete(struct usb_endpoint *ep, struct io_buffer *iobuf)
Complete transfer (without error)
Definition: usb.h:1064
static int uhci_bus_open(struct usb_bus *bus)
Open USB bus.
Definition: uhci.c:1311
#define UHCI_LINK_TYPE_QH
Queue head type.
Definition: uhci.h:84
void * data
Start of data.
Definition: iobuf.h:44
struct usb_hub * hub
USB hub.
Definition: usb.h:798
#define EIO
Input/output error.
Definition: errno.h:433
static void uhci_schedule_add(struct uhci_endpoint *endpoint)
Add endpoint to appropriate schedule.
Definition: uhci.c:639
#define UHCI_USBCMD_MAX64
Max packet is 64 bytes.
Definition: uhci.h:36
uint16_t count
Number of entries.
Definition: ena.h:22
struct usb_endpoint * ep[32]
Endpoint list.
Definition: usb.h:728
static void uhci_bus_close(struct usb_bus *bus)
Close USB bus.
Definition: uhci.c:1364
#define PCI_ARGS(pci)
PCI device debug message arguments.
Definition: pci.h:290
unsigned int interval
Interval (in microframes)
Definition: usb.h:401
static void *__malloc malloc_dma(size_t size, size_t phys_align)
Allocate memory for DMA.
Definition: malloc.h:66
uint32_t data
Buffer pointer.
Definition: uhci.h:111
struct usb_endpoint_host_operations endpoint
Endpoint operations.
Definition: usb.h:1010
#define cpu_to_le16(value)
Definition: byteswap.h:106
static void uhci_root_poll(struct usb_hub *hub, struct usb_port *port)
Poll for port status changes.
Definition: uhci.c:1279
uint32_t end
Ending offset.
Definition: netvsc.h:18
A transfer descriptor.
Definition: uhci.h:99
#define PCI_CLASS_SERIAL_USB_UHCI
UHCI USB controller.
Definition: pci.h:132
USB host controller operations.
Definition: usb.h:1008
uint32_t link
Horizontal link pointer.
Definition: uhci.h:194
#define __weak
Declare a function as weak (use before the definition)
Definition: compiler.h:219
#define DBGCP(...)
Definition: compiler.h:539
static void uhci_remove(struct pci_device *pci)
Remove PCI device.
Definition: uhci.c:1550
struct list_head list
List of all endpoints.
Definition: uhci.h:342
struct usb_hub * hub
Root hub.
Definition: usb.h:972
struct pci_driver uhci_driver __pci_driver
UHCI PCI driver.
Definition: uhci.c:1568
static int uhci_endpoint_reset(struct usb_endpoint *ep)
Reset endpoint.
Definition: uhci.c:755
static void usb_hub_set_drvdata(struct usb_hub *hub, void *priv)
Set USB hub driver private data.
Definition: usb.h:920
struct usb_device * usb
USB device.
Definition: usb.h:391
static struct usb_port * usb_port(struct usb_hub *hub, unsigned int address)
Get USB port.
Definition: usb.h:943
#define UHCI_CONTROL_PID(pid)
Packet ID.
Definition: uhci.h:157
static int uhci_reachable(void *addr, size_t len)
Check that address is reachable.
Definition: uhci.c:57
int(* open)(struct usb_endpoint *ep)
Open endpoint.
Definition: usb.h:435
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
unsigned int cons
Consumer counter.
Definition: uhci.h:213
struct uhci_transfer_descriptor * desc
Transfer descriptors.
Definition: uhci.h:218
static int uhci_root_disable(struct usb_hub *hub, struct usb_port *port)
Disable port.
Definition: uhci.c:1198
static void pci_init(struct pci_device *pci, unsigned int busdevfn)
Initialise PCI device.
Definition: pci.h:313
#define UHCI_ALIGN
Minimum alignment required for data structures.
Definition: uhci.h:21
struct usb_bus * bus
USB bus.
Definition: usb.h:828
uint64_t index
Index of the first segment within the content.
Definition: pccrc.h:21
uint16_t queue
Queue ID.
Definition: ena.h:22
static void free_dma(void *ptr, size_t size)
Free memory allocated with malloc_dma()
Definition: malloc.h:81
#define list_check_contains_entry(entry, head, member)
Check list contains a specified entry.
Definition: list.h:522
static void uhci_ring_free(struct uhci_ring *ring)
Free transfer ring.
Definition: uhci.c:207
#define USB_EP0_ADDRESS
Control endpoint address.
Definition: usb.h:486
static uint32_t uhci_link_qh(struct uhci_queue_head *queue)
Get link value for a queue head.
Definition: uhci.c:458
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
size_t mtu
Maximum packet length.
Definition: uhci.h:238
#define UHCI_CONTROL_LEN(len)
Data length.
Definition: uhci.h:172
#define ETIMEDOUT
Connection timed out.
Definition: errno.h:669
int usb_alloc_address(struct usb_bus *bus)
Allocate device address.
Definition: usb.c:2178
#define PCI_ROM(_vendor, _device, _name, _description, _data)
Definition: pci.h:283
A USB bus.
Definition: usb.h:949
unsigned int attributes
Attributes.
Definition: usb.h:395
#define UHCI_FL_SPD
Short packet detect.
Definition: uhci.h:142
static void uhci_device_close(struct usb_device *usb)
Close device.
Definition: uhci.c:1033
uint8_t bus
Bus.
Definition: edd.h:14
Full speed (12Mbps)
Definition: usb.h:50
uint32_t first
Length to skip in first segment.
Definition: pccrc.h:23
unsigned int address
Endpoint address.
Definition: usb.h:393
void free_usb_bus(struct usb_bus *bus)
Free USB bus.
Definition: usb.c:2126
static void uhci_bus_poll(struct usb_bus *bus)
Poll USB bus.
Definition: uhci.c:1386
IN PID.
Definition: usb.h:60
#define UHCI_ACTUAL_LEN(actual)
Actual length.
Definition: uhci.h:118
void usb_complete_err(struct usb_endpoint *ep, struct io_buffer *iobuf, int rc)
Complete transfer (possibly with error)
Definition: usb.c:569
static void * usb_hub_get_drvdata(struct usb_hub *hub)
Get USB hub driver private data.
Definition: usb.h:931
static int uhci_probe(struct pci_device *pci)
Probe PCI device.
Definition: uhci.c:1471
static int uhci_stop(struct uhci_device *uhci)
Stop UHCI device.
Definition: uhci.c:98
static void * usb_endpoint_get_hostdata(struct usb_endpoint *ep)
Get USB endpoint host controller private data.
Definition: usb.h:572
struct usb_bus * bus
USB bus.
Definition: uhci.h:332
String functions.
#define UHCI_FLBASEADD
Frame list base address register.
Definition: uhci.h:54
void * memset(void *dest, int character, size_t len) __nonnull
A persistent I/O buffer.
Definition: iobuf.h:32
#define UHCI_PORTS
Number of ports.
Definition: uhci.h:24