drivers/usb/c67x00/c67x00-drv.c

   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");