drivers/usb/host/uhci-platform.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Generic UHCI HCD (Host Controller Driver) for Platform Devices
   4  *
   5  * Copyright (c) 2011 Tony Prisk <linux@prisktech.co.nz>
   6  *
   7  * This file is based on uhci-grlib.c
   8  * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
   9  */
  10
  11 #include <linux/of.h>
  12 #include <linux/device.h>
  13 #include <linux/platform_device.h>
  14
  15 static int uhci_platform_init(struct usb_hcd *hcd)
  16 {
  17         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
  18
  19         /* Probe number of ports if not already provided by DT */
  20         if (!uhci->rh_numports)
  21                 uhci->rh_numports = uhci_count_ports(hcd);
  22
  23         /* Set up pointers to to generic functions */
  24         uhci->reset_hc = uhci_generic_reset_hc;
  25         uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
  26
  27         /* No special actions need to be taken for the functions below */
  28         uhci->configure_hc = NULL;
  29         uhci->resume_detect_interrupts_are_broken = NULL;
  30         uhci->global_suspend_mode_is_broken = NULL;
  31
  32         /* Reset if the controller isn't already safely quiescent. */
  33         check_and_reset_hc(uhci);
  34         return 0;
  35 }
  36
  37 static const struct hc_driver uhci_platform_hc_driver = {
  38         .description =          hcd_name,
  39         .product_desc =         "Generic UHCI Host Controller",
  40         .hcd_priv_size =        sizeof(struct uhci_hcd),
  41
  42         /* Generic hardware linkage */
  43         .irq =                  uhci_irq,
  44         .flags =                HCD_MEMORY | HCD_USB11,
  45
  46         /* Basic lifecycle operations */
  47         .reset =                uhci_platform_init,
  48         .start =                uhci_start,
  49 #ifdef CONFIG_PM
  50         .pci_suspend =          NULL,
  51         .pci_resume =           NULL,
  52         .bus_suspend =          uhci_rh_suspend,
  53         .bus_resume =           uhci_rh_resume,
  54 #endif
  55         .stop =                 uhci_stop,
  56
  57         .urb_enqueue =          uhci_urb_enqueue,
  58         .urb_dequeue =          uhci_urb_dequeue,
  59
  60         .endpoint_disable =     uhci_hcd_endpoint_disable,
  61         .get_frame_number =     uhci_hcd_get_frame_number,
  62
  63         .hub_status_data =      uhci_hub_status_data,
  64         .hub_control =          uhci_hub_control,
  65 };
  66
  67 static int uhci_hcd_platform_probe(struct platform_device *pdev)
  68 {
  69         struct device_node *np = pdev->dev.of_node;
  70         struct usb_hcd *hcd;
  71         struct uhci_hcd *uhci;
  72         struct resource *res;
  73         int ret;
  74
  75         if (usb_disabled())
  76                 return -ENODEV;
  77
  78         /*
  79          * Right now device-tree probed devices don't get dma_mask set.
  80          * Since shared usb code relies on it, set it here for now.
  81          * Once we have dma capability bindings this can go away.
  82          */
  83         ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
  84         if (ret)
  85                 return ret;
  86
  87         hcd = usb_create_hcd(&uhci_platform_hc_driver, &pdev->dev,
  88                         pdev->name);
  89         if (!hcd)
  90                 return -ENOMEM;
  91
  92         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  93         hcd->regs = devm_ioremap_resource(&pdev->dev, res);
  94         if (IS_ERR(hcd->regs)) {
  95                 ret = PTR_ERR(hcd->regs);
  96                 goto err_rmr;
  97         }
  98         hcd->rsrc_start = res->start;
  99         hcd->rsrc_len = resource_size(res);
 100
 101         uhci = hcd_to_uhci(hcd);
 102
 103         uhci->regs = hcd->regs;
 104
 105         /* Grab some things from the device-tree */
 106         if (np) {
 107                 u32 num_ports;
 108
 109                 if (of_property_read_u32(np, "#ports", &num_ports) == 0) {
 110                         uhci->rh_numports = num_ports;
 111                         dev_info(&pdev->dev,
 112                                 "Detected %d ports from device-tree\n",
 113                                 num_ports);
 114                 }
 115                 if (of_device_is_compatible(np, "aspeed,ast2400-uhci") ||
 116                     of_device_is_compatible(np, "aspeed,ast2500-uhci")) {
 117                         uhci->is_aspeed = 1;
 118                         dev_info(&pdev->dev,
 119                                  "Enabled Aspeed implementation workarounds\n");
 120                 }
 121         }
 122         ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
 123         if (ret)
 124                 goto err_rmr;
 125
 126         device_wakeup_enable(hcd->self.controller);
 127         return 0;
 128
 129 err_rmr:
 130         usb_put_hcd(hcd);
 131
 132         return ret;
 133 }
 134
 135 static int uhci_hcd_platform_remove(struct platform_device *pdev)
 136 {
 137         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 138
 139         usb_remove_hcd(hcd);
 140         usb_put_hcd(hcd);
 141
 142         return 0;
 143 }
 144
 145 /* Make sure the controller is quiescent and that we're not using it
 146  * any more.  This is mainly for the benefit of programs which, like kexec,
 147  * expect the hardware to be idle: not doing DMA or generating IRQs.
 148  *
 149  * This routine may be called in a damaged or failing kernel.  Hence we
 150  * do not acquire the spinlock before shutting down the controller.
 151  */
 152 static void uhci_hcd_platform_shutdown(struct platform_device *op)
 153 {
 154         struct usb_hcd *hcd = platform_get_drvdata(op);
 155
 156         uhci_hc_died(hcd_to_uhci(hcd));
 157 }
 158
 159 static const struct of_device_id platform_uhci_ids[] = {
 160         { .compatible = "generic-uhci", },
 161         { .compatible = "platform-uhci", },
 162         {}
 163 };
 164 MODULE_DEVICE_TABLE(of, platform_uhci_ids);
 165
 166 static struct platform_driver uhci_platform_driver = {
 167         .probe          = uhci_hcd_platform_probe,
 168         .remove         = uhci_hcd_platform_remove,
 169         .shutdown       = uhci_hcd_platform_shutdown,
 170         .driver = {
 171                 .name = "platform-uhci",
 172                 .of_match_table = platform_uhci_ids,
 173         },
 174 };