1/* 2 * Glue code for the ISP1760 driver and bus 3 * Currently there is support for 4 * - OpenFirmware 5 * - PCI 6 * - PDEV (generic platform device centralized driver model) 7 * 8 * (c) 2007 Sebastian Siewior <bigeasy@linutronix.de> 9 * 10 */ 11 12#include <linux/usb.h> 13#include <linux/io.h> 14#include <linux/platform_device.h> 15#include <linux/usb/isp1760.h> 16#include <linux/usb/hcd.h> 17 18#include "isp1760-hcd.h" 19 20#ifdef CONFIG_PPC_OF 21#include <linux/of.h> 22#include <linux/of_platform.h> 23#endif 24 25#ifdef CONFIG_PCI 26#include <linux/pci.h> 27#endif 28 29#ifdef CONFIG_PPC_OF 30static int of_isp1760_probe(struct platform_device *dev, 31 const struct of_device_id *match) 32{ 33 struct usb_hcd *hcd; 34 struct device_node *dp = dev->dev.of_node; 35 struct resource *res; 36 struct resource memory; 37 struct of_irq oirq; 38 int virq; 39 resource_size_t res_len; 40 int ret; 41 const unsigned int *prop; 42 unsigned int devflags = 0; 43 44 ret = of_address_to_resource(dp, 0, &memory); 45 if (ret) 46 return -ENXIO; 47 48 res_len = resource_size(&memory); 49 50 res = request_mem_region(memory.start, res_len, dev_name(&dev->dev)); 51 if (!res) 52 return -EBUSY; 53 54 if (of_irq_map_one(dp, 0, &oirq)) { 55 ret = -ENODEV; 56 goto release_reg; 57 } 58 59 virq = irq_create_of_mapping(oirq.controller, oirq.specifier, 60 oirq.size); 61 62 if (of_device_is_compatible(dp, "nxp,usb-isp1761")) 63 devflags |= ISP1760_FLAG_ISP1761; 64 65 /* Some systems wire up only 16 of the 32 data lines */ 66 prop = of_get_property(dp, "bus-width", NULL); 67 if (prop && *prop == 16) 68 devflags |= ISP1760_FLAG_BUS_WIDTH_16; 69 70 if (of_get_property(dp, "port1-otg", NULL) != NULL) 71 devflags |= ISP1760_FLAG_OTG_EN; 72 73 if (of_get_property(dp, "analog-oc", NULL) != NULL) 74 devflags |= ISP1760_FLAG_ANALOG_OC; 75 76 if (of_get_property(dp, "dack-polarity", NULL) != NULL) 77 devflags |= ISP1760_FLAG_DACK_POL_HIGH; 78 79 if (of_get_property(dp, "dreq-polarity", NULL) != NULL) 80 devflags |= ISP1760_FLAG_DREQ_POL_HIGH; 81 82 hcd = isp1760_register(memory.start, res_len, virq, 83 IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev), 84 devflags); 85 if (IS_ERR(hcd)) { 86 ret = PTR_ERR(hcd); 87 goto release_reg; 88 } 89 90 dev_set_drvdata(&dev->dev, hcd); 91 return ret; 92 93release_reg: 94 release_mem_region(memory.start, res_len); 95 return ret; 96} 97 98static int of_isp1760_remove(struct platform_device *dev) 99{ 100 struct usb_hcd *hcd = dev_get_drvdata(&dev->dev); 101 102 dev_set_drvdata(&dev->dev, NULL); 103 104 usb_remove_hcd(hcd); 105 iounmap(hcd->regs); 106 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 107 usb_put_hcd(hcd); 108 return 0; 109} 110 111static const struct of_device_id of_isp1760_match[] = { 112 { 113 .compatible = "nxp,usb-isp1760", 114 }, 115 { 116 .compatible = "nxp,usb-isp1761", 117 }, 118 { }, 119}; 120MODULE_DEVICE_TABLE(of, of_isp1760_match); 121 122static struct of_platform_driver isp1760_of_driver = { 123 .driver = { 124 .name = "nxp-isp1760", 125 .owner = THIS_MODULE, 126 .of_match_table = of_isp1760_match, 127 }, 128 .probe = of_isp1760_probe, 129 .remove = of_isp1760_remove, 130}; 131#endif 132 133#ifdef CONFIG_PCI 134static int __devinit isp1761_pci_probe(struct pci_dev *dev, 135 const struct pci_device_id *id) 136{ 137 u8 latency, limit; 138 __u32 reg_data; 139 int retry_count; 140 struct usb_hcd *hcd; 141 unsigned int devflags = 0; 142 int ret_status = 0; 143 144 resource_size_t pci_mem_phy0; 145 resource_size_t memlength; 146 147 u8 __iomem *chip_addr; 148 u8 __iomem *iobase; 149 resource_size_t nxp_pci_io_base; 150 resource_size_t iolength; 151 152 if (usb_disabled()) 153 return -ENODEV; 154 155 if (pci_enable_device(dev) < 0) 156 return -ENODEV; 157 158 if (!dev->irq) 159 return -ENODEV; 160 161 /* Grab the PLX PCI mem maped port start address we need */ 162 nxp_pci_io_base = pci_resource_start(dev, 0); 163 iolength = pci_resource_len(dev, 0); 164 165 if (!request_mem_region(nxp_pci_io_base, iolength, "ISP1761 IO MEM")) { 166 printk(KERN_ERR "request region #1\n"); 167 return -EBUSY; 168 } 169 170 iobase = ioremap_nocache(nxp_pci_io_base, iolength); 171 if (!iobase) { 172 printk(KERN_ERR "ioremap #1\n"); 173 ret_status = -ENOMEM; 174 goto cleanup1; 175 } 176 /* Grab the PLX PCI shared memory of the ISP 1761 we need */ 177 pci_mem_phy0 = pci_resource_start(dev, 3); 178 memlength = pci_resource_len(dev, 3); 179 if (memlength < 0xffff) { 180 printk(KERN_ERR "memory length for this resource is wrong\n"); 181 ret_status = -ENOMEM; 182 goto cleanup2; 183 } 184 185 if (!request_mem_region(pci_mem_phy0, memlength, "ISP-PCI")) { 186 printk(KERN_ERR "host controller already in use\n"); 187 ret_status = -EBUSY; 188 goto cleanup2; 189 } 190 191 /* map available memory */ 192 chip_addr = ioremap_nocache(pci_mem_phy0,memlength); 193 if (!chip_addr) { 194 printk(KERN_ERR "Error ioremap failed\n"); 195 ret_status = -ENOMEM; 196 goto cleanup3; 197 } 198 199 /* bad pci latencies can contribute to overruns */ 200 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &latency); 201 if (latency) { 202 pci_read_config_byte(dev, PCI_MAX_LAT, &limit); 203 if (limit && limit < latency) 204 pci_write_config_byte(dev, PCI_LATENCY_TIMER, limit); 205 } 206 207 /* Try to check whether we can access Scratch Register of 208 * Host Controller or not. The initial PCI access is retried until 209 * local init for the PCI bridge is completed 210 */ 211 retry_count = 20; 212 reg_data = 0; 213 while ((reg_data != 0xFACE) && retry_count) { 214 /*by default host is in 16bit mode, so 215 * io operations at this stage must be 16 bit 216 * */ 217 writel(0xface, chip_addr + HC_SCRATCH_REG); 218 udelay(100); 219 reg_data = readl(chip_addr + HC_SCRATCH_REG) & 0x0000ffff; 220 retry_count--; 221 } 222 223 iounmap(chip_addr); 224 225 /* Host Controller presence is detected by writing to scratch register 226 * and reading back and checking the contents are same or not 227 */ 228 if (reg_data != 0xFACE) { 229 dev_err(&dev->dev, "scratch register mismatch %x\n", reg_data); 230 ret_status = -ENOMEM; 231 goto cleanup3; 232 } 233 234 pci_set_master(dev); 235 236 /* configure PLX PCI chip to pass interrupts */ 237#define PLX_INT_CSR_REG 0x68 238 reg_data = readl(iobase + PLX_INT_CSR_REG); 239 reg_data |= 0x900; 240 writel(reg_data, iobase + PLX_INT_CSR_REG); 241 242 dev->dev.dma_mask = NULL; 243 hcd = isp1760_register(pci_mem_phy0, memlength, dev->irq, 244 IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev), 245 devflags); 246 if (IS_ERR(hcd)) { 247 ret_status = -ENODEV; 248 goto cleanup3; 249 } 250 251 /* done with PLX IO access */ 252 iounmap(iobase); 253 release_mem_region(nxp_pci_io_base, iolength); 254 255 pci_set_drvdata(dev, hcd); 256 return 0; 257 258cleanup3: 259 release_mem_region(pci_mem_phy0, memlength); 260cleanup2: 261 iounmap(iobase); 262cleanup1: 263 release_mem_region(nxp_pci_io_base, iolength); 264 return ret_status; 265} 266 267static void isp1761_pci_remove(struct pci_dev *dev) 268{ 269 struct usb_hcd *hcd; 270 271 hcd = pci_get_drvdata(dev); 272 273 usb_remove_hcd(hcd); 274 iounmap(hcd->regs); 275 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 276 usb_put_hcd(hcd); 277 278 pci_disable_device(dev); 279} 280 281static void isp1761_pci_shutdown(struct pci_dev *dev) 282{ 283 printk(KERN_ERR "ips1761_pci_shutdown\n"); 284} 285 286static const struct pci_device_id isp1760_plx [] = { 287 { 288 .class = PCI_CLASS_BRIDGE_OTHER << 8, 289 .class_mask = ~0, 290 .vendor = PCI_VENDOR_ID_PLX, 291 .device = 0x5406, 292 .subvendor = PCI_VENDOR_ID_PLX, 293 .subdevice = 0x9054, 294 }, 295 { } 296}; 297MODULE_DEVICE_TABLE(pci, isp1760_plx); 298 299static struct pci_driver isp1761_pci_driver = { 300 .name = "isp1760", 301 .id_table = isp1760_plx, 302 .probe = isp1761_pci_probe, 303 .remove = isp1761_pci_remove, 304 .shutdown = isp1761_pci_shutdown, 305}; 306#endif 307 308static int __devinit isp1760_plat_probe(struct platform_device *pdev) 309{ 310 int ret = 0; 311 struct usb_hcd *hcd; 312 struct resource *mem_res; 313 struct resource *irq_res; 314 resource_size_t mem_size; 315 struct isp1760_platform_data *priv = pdev->dev.platform_data; 316 unsigned int devflags = 0; 317 unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED; 318 319 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 320 if (!mem_res) { 321 pr_warning("isp1760: Memory resource not available\n"); 322 ret = -ENODEV; 323 goto out; 324 } 325 mem_size = resource_size(mem_res); 326 if (!request_mem_region(mem_res->start, mem_size, "isp1760")) { 327 pr_warning("isp1760: Cannot reserve the memory resource\n"); 328 ret = -EBUSY; 329 goto out; 330 } 331 332 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 333 if (!irq_res) { 334 pr_warning("isp1760: IRQ resource not available\n"); 335 return -ENODEV; 336 } 337 irqflags |= irq_res->flags & IRQF_TRIGGER_MASK; 338 339 if (priv) { 340 if (priv->is_isp1761) 341 devflags |= ISP1760_FLAG_ISP1761; 342 if (priv->bus_width_16) 343 devflags |= ISP1760_FLAG_BUS_WIDTH_16; 344 if (priv->port1_otg) 345 devflags |= ISP1760_FLAG_OTG_EN; 346 if (priv->analog_oc) 347 devflags |= ISP1760_FLAG_ANALOG_OC; 348 if (priv->dack_polarity_high) 349 devflags |= ISP1760_FLAG_DACK_POL_HIGH; 350 if (priv->dreq_polarity_high) 351 devflags |= ISP1760_FLAG_DREQ_POL_HIGH; 352 } 353 354 hcd = isp1760_register(mem_res->start, mem_size, irq_res->start, 355 irqflags, &pdev->dev, dev_name(&pdev->dev), devflags); 356 if (IS_ERR(hcd)) { 357 pr_warning("isp1760: Failed to register the HCD device\n"); 358 ret = -ENODEV; 359 goto cleanup; 360 } 361 362 pr_info("ISP1760 USB device initialised\n"); 363 return ret; 364 365cleanup: 366 release_mem_region(mem_res->start, mem_size); 367out: 368 return ret; 369} 370 371static int __devexit isp1760_plat_remove(struct platform_device *pdev) 372{ 373 struct resource *mem_res; 374 resource_size_t mem_size; 375 376 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 377 mem_size = resource_size(mem_res); 378 release_mem_region(mem_res->start, mem_size); 379 380 return 0; 381} 382 383static struct platform_driver isp1760_plat_driver = { 384 .probe = isp1760_plat_probe, 385 .remove = __devexit_p(isp1760_plat_remove), 386 .driver = { 387 .name = "isp1760", 388 }, 389}; 390 391static int __init isp1760_init(void) 392{ 393 int ret, any_ret = -ENODEV; 394 395 init_kmem_once(); 396 397 ret = platform_driver_register(&isp1760_plat_driver); 398 if (!ret) 399 any_ret = 0; 400#ifdef CONFIG_PPC_OF 401 ret = of_register_platform_driver(&isp1760_of_driver); 402 if (!ret) 403 any_ret = 0; 404#endif 405#ifdef CONFIG_PCI 406 ret = pci_register_driver(&isp1761_pci_driver); 407 if (!ret) 408 any_ret = 0; 409#endif 410 411 if (any_ret) 412 deinit_kmem_cache(); 413 return any_ret; 414} 415module_init(isp1760_init); 416 417static void __exit isp1760_exit(void) 418{ 419 platform_driver_unregister(&isp1760_plat_driver); 420#ifdef CONFIG_PPC_OF 421 of_unregister_platform_driver(&isp1760_of_driver); 422#endif 423#ifdef CONFIG_PCI 424 pci_unregister_driver(&isp1761_pci_driver); 425#endif 426 deinit_kmem_cache(); 427} 428module_exit(isp1760_exit); 429