drivers/usb/host/uhci-grlib.c

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