1 /** 2 * dwc3-pci.c - PCI Specific glue layer 3 * 4 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com 5 * 6 * Authors: Felipe Balbi <balbi@ti.com>, 7 * Sebastian Andrzej Siewior <bigeasy@linutronix.de> 8 * 9 * This program is free software: you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 of 11 * the License as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/slab.h> 22 #include <linux/pci.h> 23 #include <linux/platform_device.h> 24 25 #include <linux/usb/otg.h> 26 #include <linux/usb/usb_phy_gen_xceiv.h> 27 28 /* FIXME define these in <linux/pci_ids.h> */ 29 #define PCI_VENDOR_ID_SYNOPSYS 0x16c3 30 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd 31 #define PCI_DEVICE_ID_INTEL_BYT 0x0f37 32 33 struct dwc3_pci { 34 struct device *dev; 35 struct platform_device *dwc3; 36 struct platform_device *usb2_phy; 37 struct platform_device *usb3_phy; 38 }; 39 40 static int dwc3_pci_register_phys(struct dwc3_pci *glue) 41 { 42 struct usb_phy_gen_xceiv_platform_data pdata; 43 struct platform_device *pdev; 44 int ret; 45 46 memset(&pdata, 0x00, sizeof(pdata)); 47 48 pdev = platform_device_alloc("usb_phy_gen_xceiv", 0); 49 if (!pdev) 50 return -ENOMEM; 51 52 glue->usb2_phy = pdev; 53 pdata.type = USB_PHY_TYPE_USB2; 54 55 ret = platform_device_add_data(glue->usb2_phy, &pdata, sizeof(pdata)); 56 if (ret) 57 goto err1; 58 59 pdev = platform_device_alloc("usb_phy_gen_xceiv", 1); 60 if (!pdev) { 61 ret = -ENOMEM; 62 goto err1; 63 } 64 65 glue->usb3_phy = pdev; 66 pdata.type = USB_PHY_TYPE_USB3; 67 68 ret = platform_device_add_data(glue->usb3_phy, &pdata, sizeof(pdata)); 69 if (ret) 70 goto err2; 71 72 ret = platform_device_add(glue->usb2_phy); 73 if (ret) 74 goto err2; 75 76 ret = platform_device_add(glue->usb3_phy); 77 if (ret) 78 goto err3; 79 80 return 0; 81 82 err3: 83 platform_device_del(glue->usb2_phy); 84 85 err2: 86 platform_device_put(glue->usb3_phy); 87 88 err1: 89 platform_device_put(glue->usb2_phy); 90 91 return ret; 92 } 93 94 static int dwc3_pci_probe(struct pci_dev *pci, 95 const struct pci_device_id *id) 96 { 97 struct resource res[2]; 98 struct platform_device *dwc3; 99 struct dwc3_pci *glue; 100 int ret = -ENOMEM; 101 struct device *dev = &pci->dev; 102 103 glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL); 104 if (!glue) { 105 dev_err(dev, "not enough memory\n"); 106 return -ENOMEM; 107 } 108 109 glue->dev = dev; 110 111 ret = pci_enable_device(pci); 112 if (ret) { 113 dev_err(dev, "failed to enable pci device\n"); 114 return -ENODEV; 115 } 116 117 pci_set_master(pci); 118 119 ret = dwc3_pci_register_phys(glue); 120 if (ret) { 121 dev_err(dev, "couldn't register PHYs\n"); 122 return ret; 123 } 124 125 dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO); 126 if (!dwc3) { 127 dev_err(dev, "couldn't allocate dwc3 device\n"); 128 ret = -ENOMEM; 129 goto err1; 130 } 131 132 memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res)); 133 134 res[0].start = pci_resource_start(pci, 0); 135 res[0].end = pci_resource_end(pci, 0); 136 res[0].name = "dwc_usb3"; 137 res[0].flags = IORESOURCE_MEM; 138 139 res[1].start = pci->irq; 140 res[1].name = "dwc_usb3"; 141 res[1].flags = IORESOURCE_IRQ; 142 143 ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res)); 144 if (ret) { 145 dev_err(dev, "couldn't add resources to dwc3 device\n"); 146 goto err1; 147 } 148 149 pci_set_drvdata(pci, glue); 150 151 dma_set_coherent_mask(&dwc3->dev, dev->coherent_dma_mask); 152 153 dwc3->dev.dma_mask = dev->dma_mask; 154 dwc3->dev.dma_parms = dev->dma_parms; 155 dwc3->dev.parent = dev; 156 glue->dwc3 = dwc3; 157 158 ret = platform_device_add(dwc3); 159 if (ret) { 160 dev_err(dev, "failed to register dwc3 device\n"); 161 goto err3; 162 } 163 164 return 0; 165 166 err3: 167 pci_set_drvdata(pci, NULL); 168 platform_device_put(dwc3); 169 err1: 170 pci_disable_device(pci); 171 172 return ret; 173 } 174 175 static void dwc3_pci_remove(struct pci_dev *pci) 176 { 177 struct dwc3_pci *glue = pci_get_drvdata(pci); 178 179 platform_device_unregister(glue->dwc3); 180 platform_device_unregister(glue->usb2_phy); 181 platform_device_unregister(glue->usb3_phy); 182 pci_set_drvdata(pci, NULL); 183 pci_disable_device(pci); 184 } 185 186 static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = { 187 { 188 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS, 189 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3), 190 }, 191 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), }, 192 { } /* Terminating Entry */ 193 }; 194 MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table); 195 196 #ifdef CONFIG_PM_SLEEP 197 static int dwc3_pci_suspend(struct device *dev) 198 { 199 struct pci_dev *pci = to_pci_dev(dev); 200 201 pci_disable_device(pci); 202 203 return 0; 204 } 205 206 static int dwc3_pci_resume(struct device *dev) 207 { 208 struct pci_dev *pci = to_pci_dev(dev); 209 int ret; 210 211 ret = pci_enable_device(pci); 212 if (ret) { 213 dev_err(dev, "can't re-enable device --> %d\n", ret); 214 return ret; 215 } 216 217 pci_set_master(pci); 218 219 return 0; 220 } 221 #endif /* CONFIG_PM_SLEEP */ 222 223 static const struct dev_pm_ops dwc3_pci_dev_pm_ops = { 224 SET_SYSTEM_SLEEP_PM_OPS(dwc3_pci_suspend, dwc3_pci_resume) 225 }; 226 227 static struct pci_driver dwc3_pci_driver = { 228 .name = "dwc3-pci", 229 .id_table = dwc3_pci_id_table, 230 .probe = dwc3_pci_probe, 231 .remove = dwc3_pci_remove, 232 .driver = { 233 .pm = &dwc3_pci_dev_pm_ops, 234 }, 235 }; 236 237 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>"); 238 MODULE_LICENSE("GPL v2"); 239 MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer"); 240 241 module_pci_driver(dwc3_pci_driver); 242