[PATCH] jiffies.h
[opensuse:kernel.git] / drivers / usb / host / usb-uhci-hcd.c
1 /*  
2     UHCI HCD (Host Controller Driver) for USB, main part for HCD frame
3    
4     (c) 1999-2002 
5     Georg Acher      +    Deti Fliegl    +    Thomas Sailer
6     georg@acher.org      deti@fliegl.de   sailer@ife.ee.ethz.ch
7    
8     with the help of
9     David Brownell, david-b@pacbell.net 
10     Adam Richter, adam@yggdrasil.com
11     Roman Weissgaerber, weissg@vienna.at    
12     
13     HW-initalization based on material of
14     Randy Dunlap + Johannes Erdfelt + Gregory P. Smith + Linus Torvalds 
15
16     $Id: usb-uhci-hcd.c,v 1.1 2002/05/14 20:36:57 acher Exp $
17  */
18
19 #include <linux/config.h>
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/kernel.h>
23 #include <linux/delay.h>
24 #include <linux/ioport.h>
25 #include <linux/jiffies.h>
26 #include <linux/slab.h>
27 #include <linux/smp_lock.h>
28 #include <linux/errno.h>
29 #include <linux/init.h>
30 #include <linux/timer.h>
31 #include <linux/list.h>
32 #include <linux/interrupt.h>  /* for in_interrupt () */
33 #include <asm/io.h>
34 #include <asm/irq.h>
35 #include <asm/system.h>
36 #include <asm/unaligned.h>
37 #include <asm/byteorder.h>
38 #include <linux/usb.h>
39
40 #define CONFIG_USB_DEBUG
41 #ifdef CONFIG_USB_DEBUG
42         #define DEBUG
43 #else
44         #undef DEBUG
45 #endif
46
47 #include "../core/hcd.h"
48 #include "usb-uhci-hcd.h"
49
50 #define DRIVER_VERSION "$Revision: 1.1 $"
51 #define DRIVER_AUTHOR "Georg Acher, Deti Fliegl, Thomas Sailer"
52 #define DRIVER_DESC "USB 1.1 Universal Host Controller Interface driver (HCD)"
53 /*--------------------------------------------------------------------------*/
54 // Values you may tweak
55
56 /* CONFIG_USB_UHCI_HIGH_BANDWITH turns on Full Speed Bandwidth
57  * Reclamation: feature that puts loop on descriptor loop when
58  * there's some transfer going on. With FSBR, USB performance
59  * is optimal, but PCI can be slowed down up-to 5 times, slowing down
60  * system performance (eg. framebuffer devices).
61  */
62 #define CONFIG_USB_UHCI_HIGH_BANDWIDTH 
63
64 /* *_DEPTH_FIRST puts descriptor in depth-first mode. This has
65  * somehow similar effect to FSBR (higher speed), but does not
66  * slow PCI down. OTOH USB performace is slightly slower than
67  * in FSBR case and single device could hog whole USB, starving
68  * other devices.
69  */
70 #define USE_CTRL_DEPTH_FIRST 0  // 0: Breadth first, 1: Depth first
71 #define USE_BULK_DEPTH_FIRST 0  // 0: Breadth first, 1: Depth first
72
73 /* Turning off both CONFIG_USB_UHCI_HIGH_BANDWITH and *_DEPTH_FIRST
74  * will lead to <64KB/sec performance over USB for bulk transfers targeting
75  * one device's endpoint. You probably do not want to do that.
76  */
77
78 // stop bandwidth reclamation after (roughly) 50ms
79 #define IDLE_TIMEOUT  (HZ/20)
80
81 // Suppress HC interrupt error messages for 5s
82 #define ERROR_SUPPRESSION_TIME (HZ*5)
83
84 // HC watchdog
85 #define WATCHDOG_TIMEOUT (4*HZ)
86 #define MAX_REANIMATIONS 5
87
88 #define DEBUG_SYMBOLS
89 #ifdef DEBUG_SYMBOLS
90         #ifndef EXPORT_SYMTAB
91                 #define EXPORT_SYMTAB
92         #endif
93 #endif
94
95 #define queue_dbg dbg 
96 #define async_dbg dbg
97 #define init_dbg dbg
98
99 /*--------------------------------------------------------------------------*/
100 //                   NO serviceable parts below!
101 /*--------------------------------------------------------------------------*/
102
103 // How much URBs with ->next are walked
104 #define MAX_NEXT_COUNT 2048
105
106 static struct uhci *devs = NULL;
107
108 /* used by userspace UHCI data structure dumper */
109 struct uhci **uhci_devices = &devs;
110
111 /* A few prototypes */
112 static int uhci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb);
113 static int hc_reset (struct uhci_hcd *uhci);
114 static void uhci_stop (struct usb_hcd *hcd);
115 static int process_transfer (struct uhci_hcd *uhci, struct urb *urb, int mode);
116 static int process_iso (struct uhci_hcd *uhci, struct urb *urb, int mode);
117 static int process_interrupt (struct uhci_hcd *uhci, struct urb *urb, int mode);
118 static int process_urb (struct uhci_hcd *uhci, struct list_head *p);
119 static int uhci_urb_enqueue (struct usb_hcd *hcd, struct urb *urb, int mem_flags);
120 static int hc_defibrillate(struct uhci_hcd * uhci);
121 static int hc_irq_run(struct uhci_hcd *uhci);
122
123 #include "usb-uhci-dbg.c"
124 #include "usb-uhci-mem.c"
125 #include "usb-uhci-hub.c"
126 #include "usb-uhci-q.c"
127
128 #define PIPESTRING(x) (x==PIPE_BULK?"Bulk":(x==PIPE_INTERRUPT?"Interrupt":(x==PIPE_CONTROL?"Control":"Iso")))
129
130 /*--------------------------------------------------------------------------*/
131 static int uhci_urb_enqueue (struct usb_hcd *hcd, struct urb *urb, int mem_flags)
132 {
133         struct uhci_hcd *uhci = hcd_to_uhci (hcd);
134         urb_priv_t *urb_priv;
135         int ret = 0, type;
136         unsigned long flags;
137         struct urb *queued_urb=NULL;
138         int bustime;
139         type = usb_pipetype (urb->pipe);
140
141 //      err("submit_urb: scheduling %p (%s), tb %p, len %i", urb, 
142 //      PIPESTRING(type),urb->transfer_buffer,urb->transfer_buffer_length);
143
144         if (uhci->need_init) {
145                 if (in_interrupt())
146                         return -ESHUTDOWN;
147
148                 spin_lock_irqsave (&uhci->urb_list_lock, flags);
149                 ret = hc_defibrillate(uhci);
150                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
151
152                 if (ret)
153                         return ret;             
154         }
155
156         if (!uhci->running)
157                 return -ESHUTDOWN;
158
159         spin_lock_irqsave (&uhci->urb_list_lock, flags);
160
161
162         queued_urb = search_dev_ep (uhci, urb); // returns already queued urb for that pipe
163
164         if (queued_urb) {
165                 queue_dbg("found bulk urb %p\n", queued_urb);
166
167                 if (( type != PIPE_BULK) ||
168                     ((type == PIPE_BULK) &&
169                      (!(urb->transfer_flags & USB_QUEUE_BULK) || !(queued_urb->transfer_flags & USB_QUEUE_BULK)))) {
170                         spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
171                         err("ENXIO (%s)  %08x, flags %x, urb %p, burb %p, propably device driver bug...", 
172                             PIPESTRING(type),
173                             urb->pipe,urb->transfer_flags,urb,queued_urb);
174                         return -ENXIO;  // urb already queued
175                 }
176         }
177
178         urb_priv = uhci_alloc_priv(mem_flags);
179
180         if (!urb_priv) {
181                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
182                 return -ENOMEM;
183         }
184
185         urb->hcpriv = urb_priv;
186         urb_priv->urb=urb;
187         INIT_LIST_HEAD (&urb_priv->desc_list);
188         
189         if (type == PIPE_CONTROL)
190                 urb_priv->setup_packet_dma = pci_map_single(uhci->uhci_pci, urb->setup_packet,
191                                                             sizeof(struct usb_ctrlrequest), PCI_DMA_TODEVICE);
192
193         if (urb->transfer_buffer_length)
194                 urb_priv->transfer_buffer_dma = pci_map_single(uhci->uhci_pci,
195                                                                urb->transfer_buffer,
196                                                                urb->transfer_buffer_length,
197                                                                usb_pipein(urb->pipe) ?
198                                                                PCI_DMA_FROMDEVICE :
199                                                                PCI_DMA_TODEVICE);
200
201         // for bulk queuing it is essential that interrupts are disabled until submission
202         // all other type enable interrupts again
203         switch (type) {
204         case PIPE_BULK:
205                 if (queued_urb) {
206                         while (((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb)  // find last queued bulk
207                                 queued_urb=((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb;
208                                 
209                         ((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb=urb;
210                 }
211                 atomic_inc (&uhci->avoid_bulk);
212                 ret = uhci_submit_bulk_urb (uhci, urb, queued_urb);
213                 atomic_dec (&uhci->avoid_bulk);
214                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
215                 break;
216
217         case PIPE_ISOCHRONOUS:  
218                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);           
219
220                 if (urb->bandwidth == 0) {      /* not yet checked/allocated */
221                         bustime = usb_check_bandwidth (urb->dev, urb);
222                         if (bustime < 0) 
223                                 ret = bustime;
224                         else {
225                                 ret = uhci_submit_iso_urb(uhci, urb, mem_flags);
226                                 if (ret == 0)
227                                         usb_claim_bandwidth (urb->dev, urb, bustime, 1);
228                         }
229                 } else {        /* bandwidth is already set */
230                         ret = uhci_submit_iso_urb(uhci, urb, mem_flags);
231                 }
232                 break;
233
234         case PIPE_INTERRUPT:
235                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
236                 if (urb->bandwidth == 0) {      /* not yet checked/allocated */
237                         bustime = usb_check_bandwidth (urb->dev, urb);
238                         if (bustime < 0)
239                                 ret = bustime;
240                         else {
241                                 ret = uhci_submit_int_urb(uhci, urb);
242                                 if (ret == 0)
243                                         usb_claim_bandwidth (urb->dev, urb, bustime, 0);
244                         }
245                 } else {        /* bandwidth is already set */
246                         ret = uhci_submit_int_urb(uhci, urb);
247                 }
248                 break;
249
250         case PIPE_CONTROL:
251                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
252                 ret = uhci_submit_control_urb (uhci, urb);
253                 break;
254
255         default:        
256                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);
257                 ret = -EINVAL;
258         }
259
260 //      err("submit_urb: scheduled with ret: %d", ret);
261         
262         if (ret != 0)
263                 uhci_free_priv(uhci, urb, urb_priv);
264
265         return ret;
266 }
267 /*--------------------------------------------------------------------------*/
268 static int uhci_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
269 {
270         unsigned long flags=0;
271         struct uhci_hcd *uhci;
272
273         dbg("uhci_urb_dequeue called for %p",urb);
274         
275         uhci = hcd_to_uhci (hcd);
276
277         if (urb->transfer_flags & USB_ASYNC_UNLINK) {
278                 int ret;
279                 spin_lock_irqsave (&uhci->urb_list_lock, flags);
280                 ret = uhci_unlink_urb_async(uhci, urb, UNLINK_ASYNC_STORE_URB);
281                 spin_unlock_irqrestore (&uhci->urb_list_lock, flags);   
282                 return ret;
283         }
284         else
285                 return uhci_unlink_urb_sync(uhci, urb);
286 }
287 /*--------------------------------------------------------------------------*/
288 static int uhci_get_frame (struct usb_hcd *hcd)
289 {
290         struct uhci_hcd *uhci = hcd_to_uhci (hcd);
291         return inw ((int)uhci->hcd.regs + USBFRNUM);
292 }
293
294 /*--------------------------------------------------------------------------*/
295 //             Init and shutdown functions for HW 
296 /*--------------------------------------------------------------------------*/
297 static int hc_reset (struct uhci_hcd *uhci)
298 {
299         unsigned int io_addr = (int)uhci->hcd.regs;
300
301         uhci->apm_state = 0;
302         uhci->running = 0;
303         outw (USBCMD_GRESET, io_addr + USBCMD);
304         uhci_wait_ms (50);   /* Global reset for 50ms */
305         outw (0, io_addr + USBCMD);
306         uhci_wait_ms (10);      
307         return 0;
308 }
309 /*--------------------------------------------------------------------------*/
310 static int hc_irq_run(struct uhci_hcd *uhci)
311 {
312         unsigned int io_addr = (int)uhci->hcd.regs;
313         /* Turn on all interrupts */
314         outw (USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP, io_addr + USBINTR);
315
316         /* Start at frame 0 */
317         outw (0, io_addr + USBFRNUM);
318         outl (uhci->framelist_dma, io_addr + USBFLBASEADD);
319
320         /* Run and mark it configured with a 64-byte max packet */
321         outw (USBCMD_RS | USBCMD_CF | USBCMD_MAXP, io_addr + USBCMD);
322         uhci->apm_state = 1;
323         uhci->running = 1;
324         uhci->last_hcd_irq = jiffies+4*HZ;
325         return 0;
326 }
327 /*--------------------------------------------------------------------------*/
328 static int hc_start (struct uhci_hcd *uhci)
329 {
330         unsigned int io_addr = (int)uhci->hcd.regs;
331         int timeout = 10;
332         struct usb_device       *udev;
333         init_dbg("hc_start uhci %p",uhci);
334         /*
335          * Reset the HC - this will force us to get a
336          * new notification of any already connected
337          * ports due to the virtual disconnect that it
338          * implies.
339          */
340         outw (USBCMD_HCRESET, io_addr + USBCMD);
341
342         while (inw (io_addr + USBCMD) & USBCMD_HCRESET) {
343                 if (!--timeout) {
344                         err("USBCMD_HCRESET timed out!");
345                         break;
346                 }
347                 udelay(1);
348         }
349         
350         hc_irq_run(uhci);
351
352         /* connect the virtual root hub */
353         uhci->hcd.self.root_hub = udev = usb_alloc_dev (NULL, &uhci->hcd.self);
354         uhci->hcd.state = USB_STATE_READY;
355         if (!udev) {
356             uhci->running = 0;
357 // FIXME cleanup
358             return -ENOMEM;
359         }
360
361         usb_connect (udev);
362         udev->speed = USB_SPEED_FULL;
363         if (usb_register_root_hub (udev, &uhci->hcd.pdev->dev) != 0) {
364                 usb_free_dev (udev); 
365                 uhci->running = 0;
366 // FIXME cleanup
367                 return -ENODEV;
368         }
369         
370         return 0;
371 }
372
373 /*--------------------------------------------------------------------------*/
374 // Start up UHCI, find ports, init DMA lists
375
376 static int __devinit uhci_start (struct usb_hcd *hcd)
377 {
378         struct uhci_hcd *uhci = hcd_to_uhci (hcd);
379         int ret;
380         int io_addr=(int)hcd->regs, io_size=0x20; // FIXME
381         
382         init_dbg("uhci_start hcd %p uhci %p, pdev %p",hcd,uhci,hcd->pdev);
383         /* disable legacy emulation, Linux takes over... */
384         pci_write_config_word (hcd->pdev, USBLEGSUP, 0);
385
386         /* UHCI specs says devices must have 2 ports, but goes on to say */
387         /* they may have more but give no way to determine how many they */
388         /* have, so default to 2 */
389         /* According to the UHCI spec, Bit 7 is always set to 1. So we try */
390         /* to use this to our advantage */
391
392         for (uhci->maxports = 0; uhci->maxports < (io_size - 0x10) / 2; uhci->maxports++) {
393                 unsigned int portstatus;
394
395                 portstatus = inw (io_addr + 0x10 + (uhci->maxports * 2));
396                 dbg("port %i, adr %x status %x", uhci->maxports,
397                         io_addr + 0x10 + (uhci->maxports * 2), portstatus);
398                 if (!(portstatus & 0x0080))
399                         break;
400         }
401         warn("Detected %d ports", uhci->maxports);
402         
403         if (uhci->maxports < 2 || uhci->maxports > 8) {
404                 dbg("Port count misdetected, forcing to 2 ports");
405                 uhci->maxports = 2;
406         }              
407
408         ret=init_skel(uhci);
409         if (ret)
410                 return ret;
411
412         hc_reset (uhci);
413
414         if (hc_start (uhci) < 0) {
415                 err ("can't start %s", uhci->hcd.self.bus_name);
416                 uhci_stop (hcd);
417                 return -EBUSY;
418         }
419
420         // Enable PIRQ
421         pci_write_config_word (hcd->pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
422
423         set_td_ioc(uhci->td128ms); // start watchdog interrupt
424         uhci->last_hcd_irq=jiffies+5*HZ;
425
426         return 0;       
427 }
428 /*--------------------------------------------------------------------------*/
429 static void uhci_free_config (struct usb_hcd *hcd, struct usb_device *udev)
430 {
431         dbg("uhci_free_config for dev %p", udev);
432         uhci_unlink_urbs (hcd_to_uhci (hcd), udev, 0);  // Forced unlink of remaining URBs
433 }
434 /*--------------------------------------------------------------------------*/
435 static void uhci_stop (struct usb_hcd *hcd)
436 {
437         struct uhci_hcd *uhci = hcd_to_uhci (hcd);
438         
439         init_dbg("%s: stop controller", hcd->bus_name);
440         
441         uhci->running=0;
442         hc_reset (uhci);
443         wait_ms (1);
444         uhci_unlink_urbs (uhci, 0, CLEAN_FORCED);  // Forced unlink of remaining URBs
445         uhci_cleanup_unlink (uhci, CLEAN_FORCED);  // force cleanup of async killed URBs
446         cleanup_skel (uhci);
447 }
448 /*--------------------------------------------------------------------------*/
449 //                  UHCI INTERRUPT PROCESSING
450 /*--------------------------------------------------------------------------*/
451 static void uhci_irq (struct usb_hcd *hcd)
452 {       
453         struct uhci_hcd *uhci = hcd_to_uhci (hcd);
454         unsigned int io_addr = (int)hcd->regs;
455         unsigned short status;
456         struct list_head *p, *p2;
457         int restarts, work_done;
458
459         /*
460          * Read the interrupt status, and write it back to clear the
461          * interrupt cause
462          */
463
464         status = inw (io_addr + USBSTS);
465
466         if (!status)            /* shared interrupt, not mine */
467                 return;
468
469         dbg("interrupt");
470
471         uhci->last_hcd_irq=jiffies;  // for watchdog
472
473         if (status != 1) {
474                 // Avoid too much error messages at a time
475                 if (time_after(jiffies, uhci->last_error_time + ERROR_SUPPRESSION_TIME)) {
476                         warn("interrupt, status %x, frame# %i", status, 
477                              UHCI_GET_CURRENT_FRAME(uhci));
478                         uhci->last_error_time = jiffies;
479                 }
480                 
481                 // remove host controller halted state
482                 if ((status&0x20) && (uhci->running)) {
483                         err("Host controller halted, waiting for timeout.");
484 //                      outw (USBCMD_RS | inw(io_addr + USBCMD), io_addr + USBCMD);
485                 }
486                 //uhci_show_status (s);
487         }
488         /*
489          * traverse the list in *reverse* direction, because new entries
490          * may be added at the end.
491          * also, because process_urb may unlink the current urb,
492          * we need to advance the list before
493          * New: check for max. workload and restart count
494          */
495
496         spin_lock (&uhci->urb_list_lock);
497
498         restarts=0;
499         work_done=0;
500
501 restart:
502         uhci->unlink_urb_done=0;
503         p = uhci->urb_list.prev;        
504
505         while (p != &uhci->urb_list && (work_done < 1024)) {
506                 p2 = p;
507                 p = p->prev;
508
509                 process_urb (uhci, p2);
510                 
511                 work_done++;
512
513                 if (uhci->unlink_urb_done) {
514                         uhci->unlink_urb_done=0;
515                         restarts++;
516                         
517                         if (restarts<16)        // avoid endless restarts
518                                 goto restart;
519                         else 
520                                 break;
521                 }
522         }
523         if (time_after(jiffies, uhci->timeout_check + (HZ/30)))
524                 uhci_check_timeouts(uhci);
525
526         clean_descs(uhci, CLEAN_NOT_FORCED);
527         uhci_cleanup_unlink(uhci, CLEAN_NOT_FORCED);
528         uhci_switch_timer_int(uhci);
529                                                         
530         spin_unlock (&uhci->urb_list_lock);
531         
532         outw (status, io_addr + USBSTS);
533
534         //dbg("uhci_interrupt: done");
535 }
536
537 /*--------------------------------------------------------------------------*/
538 //             POWER MANAGEMENT
539
540 #ifdef  CONFIG_PM
541 static int uhci_suspend (struct usb_hcd *hcd, u32 state)
542 {
543         struct uhci_hcd         *uhci = hcd_to_uhci (hcd);
544         hc_reset(uhci);
545         return 0;
546 }
547 /*--------------------------------------------------------------------------*/
548 static int uhci_resume (struct usb_hcd *hcd)
549 {
550         struct uhci_hcd         *uhci = hcd_to_uhci (hcd);
551         hc_start(uhci);
552         return 0;
553 }
554 #endif
555 /*--------------------------------------------------------------------------*/
556 static const char       hcd_name [] = "usb-uhci-hcd";
557
558 static const struct hc_driver uhci_driver = {
559         description:            hcd_name,
560
561         // generic hardware linkage
562         irq:                    uhci_irq,
563         flags:                  HCD_USB11,
564
565         // basic lifecycle operations
566         start:                  uhci_start,
567 #ifdef  CONFIG_PM
568         suspend:                uhci_suspend,
569         resume:                 uhci_resume,
570 #endif
571         stop:                   uhci_stop,
572
573         // memory lifecycle (except per-request)
574         hcd_alloc:              uhci_hcd_alloc,
575         hcd_free:               uhci_hcd_free,
576
577         // managing i/o requests and associated device resources
578         urb_enqueue:            uhci_urb_enqueue,
579         urb_dequeue:            uhci_urb_dequeue,
580         free_config:            uhci_free_config,
581
582         // scheduling support
583         get_frame_number:       uhci_get_frame,
584
585         // root hub support
586         hub_status_data:        uhci_hub_status_data,
587         hub_control:            uhci_hub_control,
588 };
589
590 #define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
591
592 EXPORT_NO_SYMBOLS;
593 MODULE_AUTHOR (DRIVER_AUTHOR);
594 MODULE_DESCRIPTION (DRIVER_INFO);
595 MODULE_LICENSE ("GPL");
596
597 static const struct pci_device_id __devinitdata pci_ids [] = { {
598
599         /* handle any USB UHCI controller */
600         class:          (PCI_CLASS_SERIAL_USB << 8) | 0x00,
601         class_mask:     ~0,
602         driver_data:    (unsigned long) &uhci_driver,
603
604         /* no matter who makes it */
605         vendor:         PCI_ANY_ID,
606         device:         PCI_ANY_ID,
607         subvendor:      PCI_ANY_ID,
608         subdevice:      PCI_ANY_ID,
609         }, { /* end: all zeroes */ }
610 };
611
612 MODULE_DEVICE_TABLE (pci, pci_ids);
613
614 /* pci driver glue; this is a "new style" PCI driver module */
615 static struct pci_driver uhci_pci_driver = {
616         name:           (char *) hcd_name,
617         id_table:       pci_ids,
618
619         probe:          usb_hcd_pci_probe,
620         remove:         usb_hcd_pci_remove,
621
622 #ifdef  CONFIG_PM
623         suspend:        usb_hcd_pci_suspend,
624         resume:         usb_hcd_pci_resume,
625 #endif
626 };
627 /*-------------------------------------------------------------------------*/
628
629 static int __init uhci_hcd_init (void) 
630 {
631         init_dbg (DRIVER_INFO);
632         init_dbg ("block sizes: hq %d td %d",
633                 sizeof (struct qh), sizeof (struct td));
634         return pci_module_init (&uhci_pci_driver);
635 }
636
637 static void __exit uhci_hcd_cleanup (void) 
638 {       
639         pci_unregister_driver (&uhci_pci_driver);
640 }
641
642 module_init (uhci_hcd_init);
643 module_exit (uhci_hcd_cleanup);
644
645