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 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
 244 {
 245         drv->drv.name = drv->name;
 246         drv->drv.bus = &bcma_bus_type;
 247         drv->drv.owner = owner;
 248
 249         return driver_register(&drv->drv);
 250 }
 251 EXPORT_SYMBOL_GPL(__bcma_driver_register);
 252
 253 void bcma_driver_unregister(struct bcma_driver *drv)
 254 {
 255         driver_unregister(&drv->drv);
 256 }
 257 EXPORT_SYMBOL_GPL(bcma_driver_unregister);
 258
 259 static int bcma_bus_match(struct device *dev, struct device_driver *drv)
 260 {
 261         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 262         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
 263         const struct bcma_device_id *cid = &core->id;
 264         const struct bcma_device_id *did;
 265
 266         for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
 267             if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
 268                 (did->id == cid->id || did->id == BCMA_ANY_ID) &&
 269                 (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
 270                 (did->class == cid->class || did->class == BCMA_ANY_CLASS))
 271                         return 1;
 272         }
 273         return 0;
 274 }
 275
 276 static int bcma_device_probe(struct device *dev)
 277 {
 278         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 279         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
 280                                                drv);
 281         int err = 0;
 282
 283         if (adrv->probe)
 284                 err = adrv->probe(core);
 285
 286         return err;
 287 }
 288
 289 static int bcma_device_remove(struct device *dev)
 290 {
 291         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 292         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
 293                                                drv);
 294
 295         if (adrv->remove)
 296                 adrv->remove(core);
 297
 298         return 0;
 299 }
 300
 301 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 302 {
 303         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
 304
 305         return add_uevent_var(env,
 306                               "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
 307                               core->id.manuf, core->id.id,
 308                               core->id.rev, core->id.class);
 309 }
 310
 311 static int __init bcma_modinit(void)
 312 {
 313         int err;
 314
 315         err = bus_register(&bcma_bus_type);
 316         if (err)
 317                 return err;
 318
 319 #ifdef CONFIG_BCMA_HOST_PCI
 320         err = bcma_host_pci_init();
 321         if (err) {
 322                 pr_err("PCI host initialization failed\n");
 323                 err = 0;
 324         }
 325 #endif
 326
 327         return err;
 328 }
 329 fs_initcall(bcma_modinit);
 330
 331 static void __exit bcma_modexit(void)
 332 {
 333 #ifdef CONFIG_BCMA_HOST_PCI
 334         bcma_host_pci_exit();
 335 #endif
 336         bus_unregister(&bcma_bus_type);
 337 }
 338 module_exit(bcma_modexit)