1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * c67x00-drv.c: Cypress C67X00 USB Common infrastructure 4 * 5 * Copyright (C) 2006-2008 Barco N.V. 6 * Derived from the Cypress cy7c67200/300 ezusb linux driver and 7 * based on multiple host controller drivers inside the linux kernel. 8 */ 9 10 /* 11 * This file implements the common infrastructure for using the c67x00. 12 * It is both the link between the platform configuration and subdrivers and 13 * the link between the common hardware parts and the subdrivers (e.g. 14 * interrupt handling). 15 * 16 * The c67x00 has 2 SIE's (serial interface engine) which can be configured 17 * to be host, device or OTG (with some limitations, E.G. only SIE1 can be OTG). 18 * 19 * Depending on the platform configuration, the SIE's are created and 20 * the corresponding subdriver is initialized (c67x00_probe_sie). 21 */ 22 23 #include <linux/device.h> 24 #include <linux/io.h> 25 #include <linux/list.h> 26 #include <linux/slab.h> 27 #include <linux/module.h> 28 #include <linux/usb.h> 29 #include <linux/usb/c67x00.h> 30 31 #include "c67x00.h" 32 #include "c67x00-hcd.h" 33 34 static void c67x00_probe_sie(struct c67x00_sie *sie, 35 struct c67x00_device *dev, int sie_num) 36 { 37 spin_lock_init(&sie->lock); 38 sie->dev = dev; 39 sie->sie_num = sie_num; 40 sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num); 41 42 switch (sie->mode) { 43 case C67X00_SIE_HOST: 44 c67x00_hcd_probe(sie); 45 break; 46 47 case C67X00_SIE_UNUSED: 48 dev_info(sie_dev(sie), 49 "Not using SIE %d as requested\n", sie->sie_num); 50 break; 51 52 default: 53 dev_err(sie_dev(sie), 54 "Unsupported configuration: 0x%x for SIE %d\n", 55 sie->mode, sie->sie_num); 56 break; 57 } 58 } 59 60 static void c67x00_remove_sie(struct c67x00_sie *sie) 61 { 62 switch (sie->mode) { 63 case C67X00_SIE_HOST: 64 c67x00_hcd_remove(sie); 65 break; 66 67 default: 68 break; 69 } 70 } 71 72 static irqreturn_t c67x00_irq(int irq, void *__dev) 73 { 74 struct c67x00_device *c67x00 = __dev; 75 struct c67x00_sie *sie; 76 u16 msg, int_status; 77 int i, count = 8; 78 79 int_status = c67x00_ll_hpi_status(c67x00); 80 if (!int_status) 81 return IRQ_NONE; 82 83 while (int_status != 0 && (count-- >= 0)) { 84 c67x00_ll_irq(c67x00, int_status); 85 for (i = 0; i < C67X00_SIES; i++) { 86 sie = &c67x00->sie[i]; 87 msg = 0; 88 if (int_status & SIEMSG_FLG(i)) 89 msg = c67x00_ll_fetch_siemsg(c67x00, i); 90 if (sie->irq) 91 sie->irq(sie, int_status, msg); 92 } 93 int_status = c67x00_ll_hpi_status(c67x00); 94 } 95 96 if (int_status) 97 dev_warn(&c67x00->pdev->dev, "Not all interrupts handled! " 98 "status = 0x%04x\n", int_status); 99 100 return IRQ_HANDLED; 101 } 102 103 /* ------------------------------------------------------------------------- */ 104 105 static int c67x00_drv_probe(struct platform_device *pdev) 106 { 107 struct c67x00_device *c67x00; 108 struct c67x00_platform_data *pdata; 109 struct resource *res, *res2; 110 int ret, i; 111 112 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 113 if (!res) 114 return -ENODEV; 115 116 res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 117 if (!res2) 118 return -ENODEV; 119 120 pdata = dev_get_platdata(&pdev->dev); 121 if (!pdata) 122 return -ENODEV; 123 124 c67x00 = kzalloc(sizeof(*c67x00), GFP_KERNEL); 125 if (!c67x00) 126 return -ENOMEM; 127 128 if (!request_mem_region(res->start, resource_size(res), 129 pdev->name)) { 130 dev_err(&pdev->dev, "Memory region busy\n"); 131 ret = -EBUSY; 132 goto request_mem_failed; 133 } 134 c67x00->hpi.base = ioremap(res->start, resource_size(res)); 135 if (!c67x00->hpi.base) { 136 dev_err(&pdev->dev, "Unable to map HPI registers\n"); 137 ret = -EIO; 138 goto map_failed; 139 } 140 141 spin_lock_init(&c67x00->hpi.lock); 142 c67x00->hpi.regstep = pdata->hpi_regstep; 143 c67x00->pdata = dev_get_platdata(&pdev->dev); 144 c67x00->pdev = pdev; 145 146 c67x00_ll_init(c67x00); 147 c67x00_ll_hpi_reg_init(c67x00); 148 149 ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, c67x00); 150 if (ret) { 151 dev_err(&pdev->dev, "Cannot claim IRQ\n"); 152 goto request_irq_failed; 153 } 154 155 ret = c67x00_ll_reset(c67x00); 156 if (ret) { 157 dev_err(&pdev->dev, "Device reset failed\n"); 158 goto reset_failed; 159 } 160 161 for (i = 0; i < C67X00_SIES; i++) 162 c67x00_probe_sie(&c67x00->sie[i], c67x00, i); 163 164 platform_set_drvdata(pdev, c67x00); 165 166 return 0; 167 168 reset_failed: 169 free_irq(res2->start, c67x00); 170 request_irq_failed: 171 iounmap(c67x00->hpi.base); 172 map_failed: 173 release_mem_region(res->start, resource_size(res)); 174 request_mem_failed: 175 kfree(c67x00); 176 177 return ret; 178 } 179 180 static int c67x00_drv_remove(struct platform_device *pdev) 181 { 182 struct c67x00_device *c67x00 = platform_get_drvdata(pdev); 183 struct resource *res; 184 int i; 185 186 for (i = 0; i < C67X00_SIES; i++) 187 c67x00_remove_sie(&c67x00->sie[i]); 188 189 c67x00_ll_release(c67x00); 190 191 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 192 if (res) 193 free_irq(res->start, c67x00); 194 195 iounmap(c67x00->hpi.base); 196 197 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 198 if (res) 199 release_mem_region(res->start, resource_size(res)); 200 201 kfree(c67x00); 202 203 return 0; 204 } 205 206 static struct platform_driver c67x00_driver = { 207 .probe = c67x00_drv_probe, 208 .remove = c67x00_drv_remove, 209 .driver = { 210 .name = "c67x00", 211 }, 212 }; 213 214 module_platform_driver(c67x00_driver); 215 216 MODULE_AUTHOR("Peter Korsgaard, Jan Veldeman, Grant Likely"); 217 MODULE_DESCRIPTION("Cypress C67X00 USB Controller Driver"); 218 MODULE_LICENSE("GPL"); 219 MODULE_ALIAS("platform:c67x00"); 220