Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 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" |
Paul Gortmaker | 200351c | 2011-07-01 16:06:37 -0400 | [diff] [blame] | 9 | #include <linux/module.h> |
Rafał Miłecki | d57ef3a | 2012-08-10 21:23:53 +0200 | [diff] [blame] | 10 | #include <linux/platform_device.h> |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 11 | #include <linux/bcma/bcma.h> |
Geert Uytterhoeven | eef7269 | 2011-06-26 10:19:44 +0200 | [diff] [blame] | 12 | #include <linux/slab.h> |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 13 | |
| 14 | MODULE_DESCRIPTION("Broadcom's specific AMBA driver"); |
| 15 | MODULE_LICENSE("GPL"); |
| 16 | |
Hauke Mehrtens | 8f9ada4 | 2012-01-31 00:03:36 +0100 | [diff] [blame] | 17 | /* contains the number the next bus should get. */ |
| 18 | static unsigned int bcma_bus_next_num = 0; |
| 19 | |
| 20 | /* bcma_buses_mutex locks the bcma_bus_next_num */ |
| 21 | static DEFINE_MUTEX(bcma_buses_mutex); |
| 22 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 23 | static int bcma_bus_match(struct device *dev, struct device_driver *drv); |
| 24 | static int bcma_device_probe(struct device *dev); |
| 25 | static int bcma_device_remove(struct device *dev); |
David Woodhouse | 886b66e | 2011-08-19 22:14:47 +0200 | [diff] [blame] | 26 | static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 27 | |
| 28 | static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf) |
| 29 | { |
| 30 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 31 | return sprintf(buf, "0x%03X\n", core->id.manuf); |
| 32 | } |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 33 | static DEVICE_ATTR_RO(manuf); |
| 34 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 35 | static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf) |
| 36 | { |
| 37 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 38 | return sprintf(buf, "0x%03X\n", core->id.id); |
| 39 | } |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 40 | static DEVICE_ATTR_RO(id); |
| 41 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 42 | static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf) |
| 43 | { |
| 44 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 45 | return sprintf(buf, "0x%02X\n", core->id.rev); |
| 46 | } |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 47 | static DEVICE_ATTR_RO(rev); |
| 48 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 49 | static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf) |
| 50 | { |
| 51 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 52 | return sprintf(buf, "0x%X\n", core->id.class); |
| 53 | } |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 54 | static DEVICE_ATTR_RO(class); |
| 55 | |
| 56 | static struct attribute *bcma_device_attrs[] = { |
| 57 | &dev_attr_manuf.attr, |
| 58 | &dev_attr_id.attr, |
| 59 | &dev_attr_rev.attr, |
| 60 | &dev_attr_class.attr, |
| 61 | NULL, |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 62 | }; |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 63 | ATTRIBUTE_GROUPS(bcma_device); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 64 | |
| 65 | static struct bus_type bcma_bus_type = { |
| 66 | .name = "bcma", |
| 67 | .match = bcma_bus_match, |
| 68 | .probe = bcma_device_probe, |
| 69 | .remove = bcma_device_remove, |
David Woodhouse | 886b66e | 2011-08-19 22:14:47 +0200 | [diff] [blame] | 70 | .uevent = bcma_device_uevent, |
Greg Kroah-Hartman | fdcf4f8 | 2013-10-06 23:55:45 -0700 | [diff] [blame] | 71 | .dev_groups = bcma_device_groups, |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 72 | }; |
| 73 | |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 74 | static u16 bcma_cc_core_id(struct bcma_bus *bus) |
| 75 | { |
| 76 | if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706) |
| 77 | return BCMA_CORE_4706_CHIPCOMMON; |
| 78 | return BCMA_CORE_CHIPCOMMON; |
| 79 | } |
| 80 | |
Hauke Mehrtens | 929a03a | 2013-01-04 00:51:20 +0100 | [diff] [blame] | 81 | struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid, |
| 82 | u8 unit) |
Hauke Mehrtens | dfae714 | 2012-09-29 20:40:18 +0200 | [diff] [blame] | 83 | { |
| 84 | struct bcma_device *core; |
| 85 | |
| 86 | list_for_each_entry(core, &bus->cores, list) { |
| 87 | if (core->id.id == coreid && core->core_unit == unit) |
| 88 | return core; |
| 89 | } |
| 90 | return NULL; |
| 91 | } |
Hauke Mehrtens | b2395b8 | 2014-01-05 01:10:43 +0100 | [diff] [blame] | 92 | EXPORT_SYMBOL_GPL(bcma_find_core_unit); |
Hauke Mehrtens | dfae714 | 2012-09-29 20:40:18 +0200 | [diff] [blame] | 93 | |
Rafał Miłecki | 88f9b65 | 2013-06-26 10:02:11 +0200 | [diff] [blame] | 94 | bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value, |
| 95 | int timeout) |
| 96 | { |
| 97 | unsigned long deadline = jiffies + timeout; |
| 98 | u32 val; |
| 99 | |
| 100 | do { |
| 101 | val = bcma_read32(core, reg); |
| 102 | if ((val & mask) == value) |
| 103 | return true; |
| 104 | cpu_relax(); |
| 105 | udelay(10); |
| 106 | } while (!time_after_eq(jiffies, deadline)); |
| 107 | |
| 108 | bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n", reg); |
| 109 | |
| 110 | return false; |
| 111 | } |
| 112 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 113 | static void bcma_release_core_dev(struct device *dev) |
| 114 | { |
| 115 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
Hauke Mehrtens | ecd177c | 2011-07-23 01:20:08 +0200 | [diff] [blame] | 116 | if (core->io_addr) |
| 117 | iounmap(core->io_addr); |
| 118 | if (core->io_wrap) |
| 119 | iounmap(core->io_wrap); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 120 | kfree(core); |
| 121 | } |
| 122 | |
Rafał Miłecki | 37a7f87 | 2014-09-05 00:18:49 +0200 | [diff] [blame] | 123 | static bool bcma_is_core_needed_early(u16 core_id) |
| 124 | { |
| 125 | switch (core_id) { |
| 126 | case BCMA_CORE_NS_NAND: |
| 127 | case BCMA_CORE_NS_QSPI: |
| 128 | return true; |
| 129 | } |
| 130 | |
| 131 | return false; |
| 132 | } |
| 133 | |
Rafał Miłecki | 6e094bd | 2014-09-05 00:18:48 +0200 | [diff] [blame] | 134 | static void bcma_register_core(struct bcma_bus *bus, struct bcma_device *core) |
| 135 | { |
| 136 | int err; |
| 137 | |
| 138 | core->dev.release = bcma_release_core_dev; |
| 139 | core->dev.bus = &bcma_bus_type; |
| 140 | dev_set_name(&core->dev, "bcma%d:%d", bus->num, core->core_index); |
| 141 | |
| 142 | switch (bus->hosttype) { |
| 143 | case BCMA_HOSTTYPE_PCI: |
| 144 | core->dev.parent = &bus->host_pci->dev; |
| 145 | core->dma_dev = &bus->host_pci->dev; |
| 146 | core->irq = bus->host_pci->irq; |
| 147 | break; |
| 148 | case BCMA_HOSTTYPE_SOC: |
| 149 | core->dev.dma_mask = &core->dev.coherent_dma_mask; |
| 150 | core->dma_dev = &core->dev; |
| 151 | break; |
| 152 | case BCMA_HOSTTYPE_SDIO: |
| 153 | break; |
| 154 | } |
| 155 | |
| 156 | err = device_register(&core->dev); |
| 157 | if (err) { |
| 158 | bcma_err(bus, "Could not register dev for core 0x%03X\n", |
| 159 | core->id.id); |
| 160 | put_device(&core->dev); |
| 161 | return; |
| 162 | } |
| 163 | core->dev_registered = true; |
| 164 | } |
| 165 | |
| 166 | static int bcma_register_devices(struct bcma_bus *bus) |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 167 | { |
| 168 | struct bcma_device *core; |
Rafał Miłecki | 6e094bd | 2014-09-05 00:18:48 +0200 | [diff] [blame] | 169 | int err; |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 170 | |
| 171 | list_for_each_entry(core, &bus->cores, list) { |
| 172 | /* We support that cores ourself */ |
| 173 | switch (core->id.id) { |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 174 | case BCMA_CORE_4706_CHIPCOMMON: |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 175 | case BCMA_CORE_CHIPCOMMON: |
Hauke Mehrtens | 1716bcf | 2014-09-08 22:53:36 +0200 | [diff] [blame^] | 176 | case BCMA_CORE_NS_CHIPCOMMON_B: |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 177 | case BCMA_CORE_PCI: |
| 178 | case BCMA_CORE_PCIE: |
Rafał Miłecki | f473832 | 2014-07-05 01:10:41 +0200 | [diff] [blame] | 179 | case BCMA_CORE_PCIE2: |
Hauke Mehrtens | 21e0534 | 2011-07-23 01:20:09 +0200 | [diff] [blame] | 180 | case BCMA_CORE_MIPS_74K: |
Rafał Miłecki | e1ac4b4 | 2012-07-11 09:23:43 +0200 | [diff] [blame] | 181 | case BCMA_CORE_4706_MAC_GBIT_COMMON: |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 182 | continue; |
| 183 | } |
| 184 | |
Rafał Miłecki | 37a7f87 | 2014-09-05 00:18:49 +0200 | [diff] [blame] | 185 | /* Early cores were already registered */ |
| 186 | if (bcma_is_core_needed_early(core->id.id)) |
| 187 | continue; |
| 188 | |
Rafał Miłecki | 10419d0 | 2013-02-19 19:41:42 +0100 | [diff] [blame] | 189 | /* Only first GMAC core on BCM4706 is connected and working */ |
| 190 | if (core->id.id == BCMA_CORE_4706_MAC_GBIT && |
| 191 | core->core_unit > 0) |
| 192 | continue; |
| 193 | |
Rafał Miłecki | 6e094bd | 2014-09-05 00:18:48 +0200 | [diff] [blame] | 194 | bcma_register_core(bus, core); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 195 | } |
| 196 | |
Rafał Miłecki | 73e4dbe | 2013-01-25 11:37:26 +0100 | [diff] [blame] | 197 | #ifdef CONFIG_BCMA_DRIVER_MIPS |
| 198 | if (bus->drv_cc.pflash.present) { |
| 199 | err = platform_device_register(&bcma_pflash_dev); |
| 200 | if (err) |
| 201 | bcma_err(bus, "Error registering parallel flash\n"); |
| 202 | } |
| 203 | #endif |
| 204 | |
Rafał Miłecki | d57ef3a | 2012-08-10 21:23:53 +0200 | [diff] [blame] | 205 | #ifdef CONFIG_BCMA_SFLASH |
| 206 | if (bus->drv_cc.sflash.present) { |
| 207 | err = platform_device_register(&bcma_sflash_dev); |
| 208 | if (err) |
| 209 | bcma_err(bus, "Error registering serial flash\n"); |
| 210 | } |
| 211 | #endif |
| 212 | |
Rafał Miłecki | 371a004 | 2012-08-12 13:08:05 +0200 | [diff] [blame] | 213 | #ifdef CONFIG_BCMA_NFLASH |
| 214 | if (bus->drv_cc.nflash.present) { |
| 215 | err = platform_device_register(&bcma_nflash_dev); |
| 216 | if (err) |
| 217 | bcma_err(bus, "Error registering NAND flash\n"); |
| 218 | } |
| 219 | #endif |
Hauke Mehrtens | cf0936b | 2012-11-20 22:24:30 +0000 | [diff] [blame] | 220 | err = bcma_gpio_init(&bus->drv_cc); |
| 221 | if (err == -ENOTSUPP) |
| 222 | bcma_debug(bus, "GPIO driver not activated\n"); |
| 223 | else if (err) |
| 224 | bcma_err(bus, "Error registering GPIO driver: %i\n", err); |
Rafał Miłecki | 371a004 | 2012-08-12 13:08:05 +0200 | [diff] [blame] | 225 | |
Hauke Mehrtens | a4855f39 | 2012-12-05 18:46:02 +0100 | [diff] [blame] | 226 | if (bus->hosttype == BCMA_HOSTTYPE_SOC) { |
| 227 | err = bcma_chipco_watchdog_register(&bus->drv_cc); |
| 228 | if (err) |
| 229 | bcma_err(bus, "Error registering watchdog driver\n"); |
| 230 | } |
| 231 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 232 | return 0; |
| 233 | } |
| 234 | |
| 235 | static void bcma_unregister_cores(struct bcma_bus *bus) |
| 236 | { |
Piotr Haber | 1fffa90 | 2012-10-11 14:05:15 +0200 | [diff] [blame] | 237 | struct bcma_device *core, *tmp; |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 238 | |
Piotr Haber | 1fffa90 | 2012-10-11 14:05:15 +0200 | [diff] [blame] | 239 | list_for_each_entry_safe(core, tmp, &bus->cores, list) { |
| 240 | list_del(&core->list); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 241 | if (core->dev_registered) |
| 242 | device_unregister(&core->dev); |
| 243 | } |
Hauke Mehrtens | a4855f39 | 2012-12-05 18:46:02 +0100 | [diff] [blame] | 244 | if (bus->hosttype == BCMA_HOSTTYPE_SOC) |
| 245 | platform_device_unregister(bus->drv_cc.watchdog); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 246 | } |
| 247 | |
Greg Kroah-Hartman | 0f58a01 | 2012-12-21 15:12:59 -0800 | [diff] [blame] | 248 | int bcma_bus_register(struct bcma_bus *bus) |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 249 | { |
| 250 | int err; |
| 251 | struct bcma_device *core; |
| 252 | |
Hauke Mehrtens | 8f9ada4 | 2012-01-31 00:03:36 +0100 | [diff] [blame] | 253 | mutex_lock(&bcma_buses_mutex); |
| 254 | bus->num = bcma_bus_next_num++; |
| 255 | mutex_unlock(&bcma_buses_mutex); |
| 256 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 257 | /* Scan for devices (cores) */ |
| 258 | err = bcma_bus_scan(bus); |
| 259 | if (err) { |
Rafał Miłecki | 3d9d8af | 2012-07-05 22:07:32 +0200 | [diff] [blame] | 260 | bcma_err(bus, "Failed to scan: %d\n", err); |
Hauke Mehrtens | 1cabf7d | 2013-07-15 13:15:07 +0200 | [diff] [blame] | 261 | return err; |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 262 | } |
| 263 | |
Hauke Mehrtens | 30cfb02 | 2012-09-29 20:29:50 +0200 | [diff] [blame] | 264 | /* Early init CC core */ |
| 265 | core = bcma_find_core(bus, bcma_cc_core_id(bus)); |
| 266 | if (core) { |
| 267 | bus->drv_cc.core = core; |
| 268 | bcma_core_chipcommon_early_init(&bus->drv_cc); |
| 269 | } |
| 270 | |
Rafał Miłecki | 37a7f87 | 2014-09-05 00:18:49 +0200 | [diff] [blame] | 271 | /* Cores providing flash access go before SPROM init */ |
| 272 | list_for_each_entry(core, &bus->cores, list) { |
| 273 | if (bcma_is_core_needed_early(core->id.id)) |
| 274 | bcma_register_core(bus, core); |
| 275 | } |
| 276 | |
Hauke Mehrtens | 30cfb02 | 2012-09-29 20:29:50 +0200 | [diff] [blame] | 277 | /* Try to get SPROM */ |
| 278 | err = bcma_sprom_get(bus); |
| 279 | if (err == -ENOENT) { |
| 280 | bcma_err(bus, "No SPROM available\n"); |
| 281 | } else if (err) |
| 282 | bcma_err(bus, "Failed to get SPROM: %d\n", err); |
| 283 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 284 | /* Init CC core */ |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 285 | core = bcma_find_core(bus, bcma_cc_core_id(bus)); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 286 | if (core) { |
| 287 | bus->drv_cc.core = core; |
| 288 | bcma_core_chipcommon_init(&bus->drv_cc); |
| 289 | } |
| 290 | |
Hauke Mehrtens | 1716bcf | 2014-09-08 22:53:36 +0200 | [diff] [blame^] | 291 | /* Init CC core */ |
| 292 | core = bcma_find_core(bus, BCMA_CORE_NS_CHIPCOMMON_B); |
| 293 | if (core) { |
| 294 | bus->drv_cc_b.core = core; |
| 295 | bcma_core_chipcommon_b_init(&bus->drv_cc_b); |
| 296 | } |
| 297 | |
Hauke Mehrtens | 21e0534 | 2011-07-23 01:20:09 +0200 | [diff] [blame] | 298 | /* Init MIPS core */ |
| 299 | core = bcma_find_core(bus, BCMA_CORE_MIPS_74K); |
| 300 | if (core) { |
| 301 | bus->drv_mips.core = core; |
| 302 | bcma_core_mips_init(&bus->drv_mips); |
| 303 | } |
| 304 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 305 | /* Init PCIE core */ |
Hauke Mehrtens | dfae714 | 2012-09-29 20:40:18 +0200 | [diff] [blame] | 306 | core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 0); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 307 | if (core) { |
Hauke Mehrtens | dfae714 | 2012-09-29 20:40:18 +0200 | [diff] [blame] | 308 | bus->drv_pci[0].core = core; |
| 309 | bcma_core_pci_init(&bus->drv_pci[0]); |
| 310 | } |
| 311 | |
| 312 | /* Init PCIE core */ |
| 313 | core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 1); |
| 314 | if (core) { |
| 315 | bus->drv_pci[1].core = core; |
| 316 | bcma_core_pci_init(&bus->drv_pci[1]); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 317 | } |
| 318 | |
Rafał Miłecki | f473832 | 2014-07-05 01:10:41 +0200 | [diff] [blame] | 319 | /* Init PCIe Gen 2 core */ |
| 320 | core = bcma_find_core_unit(bus, BCMA_CORE_PCIE2, 0); |
| 321 | if (core) { |
| 322 | bus->drv_pcie2.core = core; |
| 323 | bcma_core_pcie2_init(&bus->drv_pcie2); |
| 324 | } |
| 325 | |
Rafał Miłecki | e1ac4b4 | 2012-07-11 09:23:43 +0200 | [diff] [blame] | 326 | /* Init GBIT MAC COMMON core */ |
| 327 | core = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON); |
| 328 | if (core) { |
| 329 | bus->drv_gmac_cmn.core = core; |
| 330 | bcma_core_gmac_cmn_init(&bus->drv_gmac_cmn); |
| 331 | } |
| 332 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 333 | /* Register found cores */ |
Rafał Miłecki | 6e094bd | 2014-09-05 00:18:48 +0200 | [diff] [blame] | 334 | bcma_register_devices(bus); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 335 | |
Rafał Miłecki | 3d9d8af | 2012-07-05 22:07:32 +0200 | [diff] [blame] | 336 | bcma_info(bus, "Bus registered\n"); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 337 | |
| 338 | return 0; |
| 339 | } |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 340 | |
| 341 | void bcma_bus_unregister(struct bcma_bus *bus) |
| 342 | { |
Saul St. John | ee91592 | 2012-08-16 15:42:30 -0500 | [diff] [blame] | 343 | struct bcma_device *cores[3]; |
Hauke Mehrtens | c50ae94 | 2013-02-03 23:25:33 +0100 | [diff] [blame] | 344 | int err; |
| 345 | |
| 346 | err = bcma_gpio_unregister(&bus->drv_cc); |
| 347 | if (err == -EBUSY) |
| 348 | bcma_err(bus, "Some GPIOs are still in use.\n"); |
| 349 | else if (err) |
| 350 | bcma_err(bus, "Can not unregister GPIO driver: %i\n", err); |
Saul St. John | ee91592 | 2012-08-16 15:42:30 -0500 | [diff] [blame] | 351 | |
Hauke Mehrtens | 1716bcf | 2014-09-08 22:53:36 +0200 | [diff] [blame^] | 352 | bcma_core_chipcommon_b_free(&bus->drv_cc_b); |
| 353 | |
Saul St. John | ee91592 | 2012-08-16 15:42:30 -0500 | [diff] [blame] | 354 | cores[0] = bcma_find_core(bus, BCMA_CORE_MIPS_74K); |
| 355 | cores[1] = bcma_find_core(bus, BCMA_CORE_PCIE); |
| 356 | cores[2] = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON); |
| 357 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 358 | bcma_unregister_cores(bus); |
Saul St. John | ee91592 | 2012-08-16 15:42:30 -0500 | [diff] [blame] | 359 | |
| 360 | kfree(cores[2]); |
| 361 | kfree(cores[1]); |
| 362 | kfree(cores[0]); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 363 | } |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 364 | |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 365 | int __init bcma_bus_early_register(struct bcma_bus *bus, |
| 366 | struct bcma_device *core_cc, |
| 367 | struct bcma_device *core_mips) |
| 368 | { |
| 369 | int err; |
| 370 | struct bcma_device *core; |
| 371 | struct bcma_device_id match; |
| 372 | |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 373 | match.manuf = BCMA_MANUF_BCM; |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 374 | match.id = bcma_cc_core_id(bus); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 375 | match.class = BCMA_CL_SIM; |
| 376 | match.rev = BCMA_ANY_REV; |
| 377 | |
| 378 | /* Scan for chip common core */ |
| 379 | err = bcma_bus_scan_early(bus, &match, core_cc); |
| 380 | if (err) { |
Rafał Miłecki | 3d9d8af | 2012-07-05 22:07:32 +0200 | [diff] [blame] | 381 | bcma_err(bus, "Failed to scan for common core: %d\n", err); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 382 | return -1; |
| 383 | } |
| 384 | |
| 385 | match.manuf = BCMA_MANUF_MIPS; |
| 386 | match.id = BCMA_CORE_MIPS_74K; |
| 387 | match.class = BCMA_CL_SIM; |
| 388 | match.rev = BCMA_ANY_REV; |
| 389 | |
| 390 | /* Scan for mips core */ |
| 391 | err = bcma_bus_scan_early(bus, &match, core_mips); |
| 392 | if (err) { |
Rafał Miłecki | 3d9d8af | 2012-07-05 22:07:32 +0200 | [diff] [blame] | 393 | bcma_err(bus, "Failed to scan for mips core: %d\n", err); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 394 | return -1; |
| 395 | } |
| 396 | |
Hauke Mehrtens | 49655bb | 2012-09-29 20:29:49 +0200 | [diff] [blame] | 397 | /* Early init CC core */ |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 398 | core = bcma_find_core(bus, bcma_cc_core_id(bus)); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 399 | if (core) { |
| 400 | bus->drv_cc.core = core; |
Hauke Mehrtens | 49655bb | 2012-09-29 20:29:49 +0200 | [diff] [blame] | 401 | bcma_core_chipcommon_early_init(&bus->drv_cc); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 402 | } |
| 403 | |
Hauke Mehrtens | 49655bb | 2012-09-29 20:29:49 +0200 | [diff] [blame] | 404 | /* Early init MIPS core */ |
Hauke Mehrtens | 21e0534 | 2011-07-23 01:20:09 +0200 | [diff] [blame] | 405 | core = bcma_find_core(bus, BCMA_CORE_MIPS_74K); |
| 406 | if (core) { |
| 407 | bus->drv_mips.core = core; |
Hauke Mehrtens | 49655bb | 2012-09-29 20:29:49 +0200 | [diff] [blame] | 408 | bcma_core_mips_early_init(&bus->drv_mips); |
Hauke Mehrtens | 21e0534 | 2011-07-23 01:20:09 +0200 | [diff] [blame] | 409 | } |
| 410 | |
Rafał Miłecki | 3d9d8af | 2012-07-05 22:07:32 +0200 | [diff] [blame] | 411 | bcma_info(bus, "Early bus registered\n"); |
Hauke Mehrtens | 517f43e | 2011-07-23 01:20:07 +0200 | [diff] [blame] | 412 | |
| 413 | return 0; |
| 414 | } |
| 415 | |
Rafał Miłecki | 775ab52 | 2011-12-09 22:16:07 +0100 | [diff] [blame] | 416 | #ifdef CONFIG_PM |
Linus Torvalds | 685a4ef | 2012-01-13 23:58:40 +0100 | [diff] [blame] | 417 | int bcma_bus_suspend(struct bcma_bus *bus) |
| 418 | { |
Linus Torvalds | 7d5869e | 2012-01-13 23:58:41 +0100 | [diff] [blame] | 419 | struct bcma_device *core; |
| 420 | |
| 421 | list_for_each_entry(core, &bus->cores, list) { |
| 422 | struct device_driver *drv = core->dev.driver; |
| 423 | if (drv) { |
| 424 | struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv); |
| 425 | if (adrv->suspend) |
| 426 | adrv->suspend(core); |
| 427 | } |
| 428 | } |
Linus Torvalds | 685a4ef | 2012-01-13 23:58:40 +0100 | [diff] [blame] | 429 | return 0; |
| 430 | } |
| 431 | |
Rafał Miłecki | 775ab52 | 2011-12-09 22:16:07 +0100 | [diff] [blame] | 432 | int bcma_bus_resume(struct bcma_bus *bus) |
| 433 | { |
| 434 | struct bcma_device *core; |
| 435 | |
| 436 | /* Init CC core */ |
Rafał Miłecki | 6d5cfc9 | 2012-07-10 23:45:49 +0200 | [diff] [blame] | 437 | if (bus->drv_cc.core) { |
Rafał Miłecki | 775ab52 | 2011-12-09 22:16:07 +0100 | [diff] [blame] | 438 | bus->drv_cc.setup_done = false; |
| 439 | bcma_core_chipcommon_init(&bus->drv_cc); |
| 440 | } |
| 441 | |
Linus Torvalds | 7d5869e | 2012-01-13 23:58:41 +0100 | [diff] [blame] | 442 | list_for_each_entry(core, &bus->cores, list) { |
| 443 | struct device_driver *drv = core->dev.driver; |
| 444 | if (drv) { |
| 445 | struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv); |
| 446 | if (adrv->resume) |
| 447 | adrv->resume(core); |
| 448 | } |
| 449 | } |
| 450 | |
Rafał Miłecki | 775ab52 | 2011-12-09 22:16:07 +0100 | [diff] [blame] | 451 | return 0; |
| 452 | } |
| 453 | #endif |
| 454 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 455 | int __bcma_driver_register(struct bcma_driver *drv, struct module *owner) |
| 456 | { |
| 457 | drv->drv.name = drv->name; |
| 458 | drv->drv.bus = &bcma_bus_type; |
| 459 | drv->drv.owner = owner; |
| 460 | |
| 461 | return driver_register(&drv->drv); |
| 462 | } |
| 463 | EXPORT_SYMBOL_GPL(__bcma_driver_register); |
| 464 | |
| 465 | void bcma_driver_unregister(struct bcma_driver *drv) |
| 466 | { |
| 467 | driver_unregister(&drv->drv); |
| 468 | } |
| 469 | EXPORT_SYMBOL_GPL(bcma_driver_unregister); |
| 470 | |
| 471 | static int bcma_bus_match(struct device *dev, struct device_driver *drv) |
| 472 | { |
| 473 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 474 | struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv); |
| 475 | const struct bcma_device_id *cid = &core->id; |
| 476 | const struct bcma_device_id *did; |
| 477 | |
| 478 | for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) { |
| 479 | if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) && |
| 480 | (did->id == cid->id || did->id == BCMA_ANY_ID) && |
| 481 | (did->rev == cid->rev || did->rev == BCMA_ANY_REV) && |
| 482 | (did->class == cid->class || did->class == BCMA_ANY_CLASS)) |
| 483 | return 1; |
| 484 | } |
| 485 | return 0; |
| 486 | } |
| 487 | |
| 488 | static int bcma_device_probe(struct device *dev) |
| 489 | { |
| 490 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 491 | struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver, |
| 492 | drv); |
| 493 | int err = 0; |
| 494 | |
| 495 | if (adrv->probe) |
| 496 | err = adrv->probe(core); |
| 497 | |
| 498 | return err; |
| 499 | } |
| 500 | |
| 501 | static int bcma_device_remove(struct device *dev) |
| 502 | { |
| 503 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 504 | struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver, |
| 505 | drv); |
| 506 | |
| 507 | if (adrv->remove) |
| 508 | adrv->remove(core); |
| 509 | |
| 510 | return 0; |
| 511 | } |
| 512 | |
David Woodhouse | 886b66e | 2011-08-19 22:14:47 +0200 | [diff] [blame] | 513 | static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env) |
| 514 | { |
| 515 | struct bcma_device *core = container_of(dev, struct bcma_device, dev); |
| 516 | |
| 517 | return add_uevent_var(env, |
| 518 | "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X", |
| 519 | core->id.manuf, core->id.id, |
| 520 | core->id.rev, core->id.class); |
| 521 | } |
| 522 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 523 | static int __init bcma_modinit(void) |
| 524 | { |
| 525 | int err; |
| 526 | |
| 527 | err = bus_register(&bcma_bus_type); |
| 528 | if (err) |
| 529 | return err; |
| 530 | |
| 531 | #ifdef CONFIG_BCMA_HOST_PCI |
| 532 | err = bcma_host_pci_init(); |
| 533 | if (err) { |
| 534 | pr_err("PCI host initialization failed\n"); |
| 535 | err = 0; |
| 536 | } |
| 537 | #endif |
| 538 | |
| 539 | return err; |
| 540 | } |
| 541 | fs_initcall(bcma_modinit); |
| 542 | |
| 543 | static void __exit bcma_modexit(void) |
| 544 | { |
| 545 | #ifdef CONFIG_BCMA_HOST_PCI |
| 546 | bcma_host_pci_exit(); |
| 547 | #endif |
| 548 | bus_unregister(&bcma_bus_type); |
| 549 | } |
| 550 | module_exit(bcma_modexit) |