drivers/bcma/main.c

   1 /*
   2  * Broadcom specific AMBA
   3  * Bus subsystem
   4  *
   5  * Licensed under the GNU/GPL. See COPYING for details.
   6  */
   7
   8 #include "bcma_private.h"
   9 #include <linux/module.h>
  10 #include <linux/bcma/bcma.h>
  11 #include <linux/slab.h>
  12
  13 MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
  14 MODULE_LICENSE("GPL");
  15
  16 static int bcma_bus_match(struct device *dev, struct device_driver *drv);
  17 static int bcma_device_probe(struct device *dev);
  18 static int bcma_device_remove(struct device *dev);
  19 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
  20
  21 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
  22 {
  23         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
  24         return sprintf(buf, "0x%03X\n", core->id.manuf);
  25 }
  26 static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
  27 {
  28         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
  29         return sprintf(buf, "0x%03X\n", core->id.id);
  30 }
  31 static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
  32 {
  33         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
  34         return sprintf(buf, "0x%02X\n", core->id.rev);
  35 }
  36 static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
  37 {
  38         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
  39         return sprintf(buf, "0x%X\n", core->id.class);
  40 }
  41 static struct device_attribute bcma_device_attrs[] = {
  42         __ATTR_RO(manuf),
  43         __ATTR_RO(id),
  44         __ATTR_RO(rev),
  45         __ATTR_RO(class),
  46         __ATTR_NULL,
  47 };
  48
  49 static struct bus_type bcma_bus_type = {
  50         .name           = "bcma",
  51         .match          = bcma_bus_match,
  52         .probe          = bcma_device_probe,
  53         .remove         = bcma_device_remove,
  54         .uevent         = bcma_device_uevent,
  55         .dev_attrs      = bcma_device_attrs,
  56 };
  57
  58 static struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
  59 {
  60         struct bcma_device *core;
  61
  62         list_for_each_entry(core, &bus->cores, list) {
  63                 if (core->id.id == coreid)
  64                         return core;
  65         }
  66         return NULL;
  67 }
  68
  69 static void bcma_release_core_dev(struct device *dev)
  70 {
  71         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
  72         if (core->io_addr)
  73                 iounmap(core->io_addr);
  74         if (core->io_wrap)
  75                 iounmap(core->io_wrap);
  76         kfree(core);
  77 }
  78
  79 static int bcma_register_cores(struct bcma_bus *bus)
  80 {
  81         struct bcma_device *core;
  82         int err, dev_id = 0;
  83
  84         list_for_each_entry(core, &bus->cores, list) {
  85                 /* We support that cores ourself */
  86                 switch (core->id.id) {
  87                 case BCMA_CORE_CHIPCOMMON:
  88                 case BCMA_CORE_PCI:
  89                 case BCMA_CORE_PCIE:
  90                 case BCMA_CORE_MIPS_74K:
  91                         continue;
  92                 }
  93
  94                 core->dev.release = bcma_release_core_dev;
  95                 core->dev.bus = &bcma_bus_type;
  96                 dev_set_name(&core->dev, "bcma%d:%d", 0/*bus->num*/, dev_id);
  97
  98                 switch (bus->hosttype) {
  99                 case BCMA_HOSTTYPE_PCI:
 100                         core->dev.parent = &bus->host_pci->dev;
 101                         core->dma_dev = &bus->host_pci->dev;
 102                         core->irq = bus->host_pci->irq;
 103                         break;
 104                 case BCMA_HOSTTYPE_SOC:
 105                         core->dev.dma_mask = &core->dev.coherent_dma_mask;
 106                         core->dma_dev = &core->dev;
 107                         break;
 108                 case BCMA_HOSTTYPE_SDIO:
 109                         break;
 110                 }
 111
 112                 err = device_register(&core->dev);
 113                 if (err) {
 114                         pr_err("Could not register dev for core 0x%03X\n",
 115                                core->id.id);
 116                         continue;
 117                 }
 118                 core->dev_registered = true;
 119                 dev_id++;
 120         }
 121
 122         return 0;
 123 }
 124
 125 static void bcma_unregister_cores(struct bcma_bus *bus)
 126 {
 127         struct bcma_device *core;
 128
 129         list_for_each_entry(core, &bus->cores, list) {
 130                 if (core->dev_registered)
 131                         device_unregister(&core->dev);
 132         }
 133 }
 134
 135 int bcma_bus_register(struct bcma_bus *bus)
 136 {
 137         int err;
 138         struct bcma_device *core;
 139
 140         /* Scan for devices (cores) */
 141         err = bcma_bus_scan(bus);
 142         if (err) {
 143                 pr_err("Failed to scan: %d\n", err);
 144                 return -1;
 145         }
 146
 147         /* Init CC core */
 148         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 149         if (core) {
 150                 bus->drv_cc.core = core;
 151                 bcma_core_chipcommon_init(&bus->drv_cc);
 152         }
 153
 154         /* Init MIPS core */
 155         core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
 156         if (core) {
 157                 bus->drv_mips.core = core;
 158                 bcma_core_mips_init(&bus->drv_mips);
 159         }
 160
 161         /* Init PCIE core */
 162         core = bcma_find_core(bus, BCMA_CORE_PCIE);
 163         if (core) {
 164                 bus->drv_pci.core = core;
 165                 bcma_core_pci_init(&bus->drv_pci);
 166         }
 167
 168         /* Try to get SPROM */
 169         err = bcma_sprom_get(bus);
 170         if (err == -ENOENT) {
 171                 pr_err("No SPROM available\n");
 172         } else if (err) {
 173                 pr_err("Failed to get SPROM: %d\n", err);
 174                 return -ENOENT;
 175         }
 176
 177         /* Register found cores */
 178         bcma_register_cores(bus);
 179
 180         pr_info("Bus registered\n");
 181
 182         return 0;
 183 }
 184
 185 void bcma_bus_unregister(struct bcma_bus *bus)
 186 {
 187         bcma_unregister_cores(bus);
 188 }
 189
 190 int __init bcma_bus_early_register(struct bcma_bus *bus,
 191                                    struct bcma_device *core_cc,
 192                                    struct bcma_device *core_mips)
 193 {
 194         int err;
 195         struct bcma_device *core;
 196         struct bcma_device_id match;
 197
 198         bcma_init_bus(bus);
 199
 200         match.manuf = BCMA_MANUF_BCM;
 201         match.id = BCMA_CORE_CHIPCOMMON;
 202         match.class = BCMA_CL_SIM;
 203         match.rev = BCMA_ANY_REV;
 204
 205         /* Scan for chip common core */
 206         err = bcma_bus_scan_early(bus, &match, core_cc);
 207         if (err) {
 208                 pr_err("Failed to scan for common core: %d\n", err);
 209                 return -1;
 210         }
 211
 212         match.manuf = BCMA_MANUF_MIPS;
 213         match.id = BCMA_CORE_MIPS_74K;
 214         match.class = BCMA_CL_SIM;
 215         match.rev = BCMA_ANY_REV;
 216
 217         /* Scan for mips core */
 218         err = bcma_bus_scan_early(bus, &match, core_mips);
 219         if (err) {
 220                 pr_err("Failed to scan for mips core: %d\n", err);
 221                 return -1;
 222         }
 223
 224         /* Init CC core */
 225         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 226         if (core) {
 227                 bus->drv_cc.core = core;
 228                 bcma_core_chipcommon_init(&bus->drv_cc);
 229         }
 230
 231         /* Init MIPS core */
 232         core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
 233         if (core) {
 234                 bus->drv_mips.core = core;
 235                 bcma_core_mips_init(&bus->drv_mips);
 236         }
 237
 238         pr_info("Early bus registered\n");
 239
 240         return 0;
 241 }
 242
 243 #ifdef CONFIG_PM
 244 int bcma_bus_resume(struct bcma_bus *bus)
 245 {
 246         struct bcma_device *core;
 247
 248         /* Init CC core */
 249         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 250         if (core) {
 251                 bus->drv_cc.setup_done = false;
 252                 bcma_core_chipcommon_init(&bus->drv_cc);
 253         }
 254
 255         return 0;
 256 }
 257 #endif
 258
 259 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
 260 {
 261         drv->drv.name = drv->name;
 262         drv->drv.bus = &bcma_bus_type;
 263         drv->drv.owner = owner;
 264
 265         return driver_register(&drv->drv);
 266 }
 267 EXPORT_SYMBOL_GPL(__bcma_driver_register);
 268
 269 void bcma_driver_unregister(struct bcma_driver *drv)
 270 {
 271         driver_unregister(&drv->drv);
 272 }
 273 EXPORT_SYMBOL_GPL(bcma_driver_unregister);
 274
 275 static int bcma_bus_match(struct device *dev, struct device_driver *drv)
 276 {
 277         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 278         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
 279         const struct bcma_device_id *cid = &core->id;
 280         const struct bcma_device_id *did;
 281
 282         for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
 283             if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
 284                 (did->id == cid->id || did->id == BCMA_ANY_ID) &&
 285                 (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
 286                 (did->class == cid->class || did->class == BCMA_ANY_CLASS))
 287                         return 1;
 288         }
 289         return 0;
 290 }
 291
 292 static int bcma_device_probe(struct device *dev)
 293 {
 294         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 295         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
 296                                                drv);
 297         int err = 0;
 298
 299         if (adrv->probe)
 300                 err = adrv->probe(core);
 301
 302         return err;
 303 }
 304
 305 static int bcma_device_remove(struct device *dev)
 306 {
 307         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 308         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
 309                                                drv);
 310
 311         if (adrv->remove)
 312                 adrv->remove(core);
 313
 314         return 0;
 315 }
 316
 317 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 318 {
 319         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 320
 321         return add_uevent_var(env,
 322                               "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
 323                               core->id.manuf, core->id.id,
 324                               core->id.rev, core->id.class);
 325 }
 326
 327 static int __init bcma_modinit(void)
 328 {
 329         int err;
 330
 331         err = bus_register(&bcma_bus_type);
 332         if (err)
 333                 return err;
 334
 335 #ifdef CONFIG_BCMA_HOST_PCI
 336         err = bcma_host_pci_init();
 337         if (err) {
 338                 pr_err("PCI host initialization failed\n");
 339                 err = 0;
 340         }
 341 #endif
 342
 343         return err;
 344 }
 345 fs_initcall(bcma_modinit);
 346
 347 static void __exit bcma_modexit(void)
 348 {
 349 #ifdef CONFIG_BCMA_HOST_PCI
 350         bcma_host_pci_exit();
 351 #endif
 352         bus_unregister(&bcma_bus_type);
 353 }
 354 module_exit(bcma_modexit)