drivers/usb/host/uhci-grlib.c

   1 /*
   2  * UHCI HCD (Host Controller Driver) for GRLIB GRUSBHC
   3  *
   4  * Copyright (c) 2011 Jan Andersson <jan@gaisler.com>
   5  *
   6  * This file is based on UHCI PCI HCD:
   7  * (C) Copyright 1999 Linus Torvalds
   8  * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
   9  * (C) Copyright 1999 Randy Dunlap
  10  * (C) Copyright 1999 Georg Acher, acher@in.tum.de
  11  * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
  12  * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
  13  * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
  14  * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
  15  *               support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
  16  * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
  17  * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
  18  */
  19
  20 #include <linux/device.h>
  21 #include <linux/of_irq.h>
  22 #include <linux/of_address.h>
  23 #include <linux/of_platform.h>
  24
  25 static int uhci_grlib_init(struct usb_hcd *hcd)
  26 {
  27         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
  28
  29         /*
  30          * Probe to determine the endianness of the controller.
  31          * We know that bit 7 of the PORTSC1 register is always set
  32          * and bit 15 is always clear.  If uhci_readw() yields a value
  33          * with bit 7 (0x80) turned on then the current little-endian
  34          * setting is correct.  Otherwise we assume the value was
  35          * byte-swapped; hence the register interface and presumably
  36          * also the descriptors are big-endian.
  37          */
  38         if (!(uhci_readw(uhci, USBPORTSC1) & 0x80)) {
  39                 uhci->big_endian_mmio = 1;
  40                 uhci->big_endian_desc = 1;
  41         }
  42
  43         uhci->rh_numports = uhci_count_ports(hcd);
  44
  45         /* Set up pointers to to generic functions */
  46         uhci->reset_hc = uhci_generic_reset_hc;
  47         uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
  48         /* No special actions need to be taken for the functions below */
  49         uhci->configure_hc = NULL;
  50         uhci->resume_detect_interrupts_are_broken = NULL;
  51         uhci->global_suspend_mode_is_broken = NULL;
  52
  53         /* Reset if the controller isn't already safely quiescent. */
  54         check_and_reset_hc(uhci);
  55         return 0;
  56 }
  57
  58 static const struct hc_driver uhci_grlib_hc_driver = {
  59         .description =          hcd_name,
  60         .product_desc =         "GRLIB GRUSBHC UHCI Host Controller",
  61         .hcd_priv_size =        sizeof(struct uhci_hcd),
  62
  63         /* Generic hardware linkage */
  64         .irq =                  uhci_irq,
  65         .flags =                HCD_MEMORY | HCD_USB11,
  66
  67         /* Basic lifecycle operations */
  68         .reset =                uhci_grlib_init,
  69         .start =                uhci_start,
  70 #ifdef CONFIG_PM
  71         .pci_suspend =          NULL,
  72         .pci_resume =           NULL,
  73         .bus_suspend =          uhci_rh_suspend,
  74         .bus_resume =           uhci_rh_resume,
  75 #endif
  76         .stop =                 uhci_stop,
  77
  78         .urb_enqueue =          uhci_urb_enqueue,
  79         .urb_dequeue =          uhci_urb_dequeue,
  80
  81         .endpoint_disable =     uhci_hcd_endpoint_disable,
  82         .get_frame_number =     uhci_hcd_get_frame_number,
  83
  84         .hub_status_data =      uhci_hub_status_data,
  85         .hub_control =          uhci_hub_control,
  86 };
  87
  88
  89 static int uhci_hcd_grlib_probe(struct platform_device *op)
  90 {
  91         struct device_node *dn = op->dev.of_node;
  92         struct usb_hcd *hcd;
  93         struct uhci_hcd *uhci = NULL;
  94         struct resource res;
  95         int irq;
  96         int rv;
  97
  98         if (usb_disabled())
  99                 return -ENODEV;
 100
 101         dev_dbg(&op->dev, "initializing GRUSBHC UHCI USB Controller\n");
 102
 103         rv = of_address_to_resource(dn, 0, &res);
 104         if (rv)
 105                 return rv;
 106
 107         /* usb_create_hcd requires dma_mask != NULL */
 108         op->dev.dma_mask = &op->dev.coherent_dma_mask;
 109         hcd = usb_create_hcd(&uhci_grlib_hc_driver, &op->dev,
 110                         "GRUSBHC UHCI USB");
 111         if (!hcd)
 112                 return -ENOMEM;
 113
 114         hcd->rsrc_start = res.start;
 115         hcd->rsrc_len = resource_size(&res);
 116
 117         irq = irq_of_parse_and_map(dn, 0);
 118         if (irq == NO_IRQ) {
 119                 printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
 120                 rv = -EBUSY;
 121                 goto err_usb;
 122         }
 123
 124         hcd->regs = devm_ioremap_resource(&op->dev, &res);
 125         if (IS_ERR(hcd->regs)) {
 126                 rv = PTR_ERR(hcd->regs);
 127                 goto err_irq;
 128         }
 129
 130         uhci = hcd_to_uhci(hcd);
 131
 132         uhci->regs = hcd->regs;
 133
 134         rv = usb_add_hcd(hcd, irq, 0);
 135         if (rv)
 136                 goto err_irq;
 137
 138         device_wakeup_enable(hcd->self.controller);
 139         return 0;
 140
 141 err_irq:
 142         irq_dispose_mapping(irq);
 143 err_usb:
 144         usb_put_hcd(hcd);
 145
 146         return rv;
 147 }
 148
 149 static int uhci_hcd_grlib_remove(struct platform_device *op)
 150 {
 151         struct usb_hcd *hcd = platform_get_drvdata(op);
 152
 153         dev_dbg(&op->dev, "stopping GRLIB GRUSBHC UHCI USB Controller\n");
 154
 155         usb_remove_hcd(hcd);
 156
 157         irq_dispose_mapping(hcd->irq);
 158         usb_put_hcd(hcd);
 159
 160         return 0;
 161 }
 162
 163 /* Make sure the controller is quiescent and that we're not using it
 164  * any more.  This is mainly for the benefit of programs which, like kexec,
 165  * expect the hardware to be idle: not doing DMA or generating IRQs.
 166  *
 167  * This routine may be called in a damaged or failing kernel.  Hence we
 168  * do not acquire the spinlock before shutting down the controller.
 169  */
 170 static void uhci_hcd_grlib_shutdown(struct platform_device *op)
 171 {
 172         struct usb_hcd *hcd = platform_get_drvdata(op);
 173
 174         uhci_hc_died(hcd_to_uhci(hcd));
 175 }
 176
 177 static const struct of_device_id uhci_hcd_grlib_of_match[] = {
 178         { .name = "GAISLER_UHCI", },
 179         { .name = "01_027", },
 180         {},
 181 };
 182 MODULE_DEVICE_TABLE(of, uhci_hcd_grlib_of_match);
 183
 184
 185 static struct platform_driver uhci_grlib_driver = {
 186         .probe          = uhci_hcd_grlib_probe,
 187         .remove         = uhci_hcd_grlib_remove,
 188         .shutdown       = uhci_hcd_grlib_shutdown,
 189         .driver = {
 190                 .name = "grlib-uhci",
 191                 .of_match_table = uhci_hcd_grlib_of_match,
 192         },
 193 };