scan.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525
  1. /*
  2. * Broadcom specific AMBA
  3. * Bus scanning
  4. *
  5. * Licensed under the GNU/GPL. See COPYING for details.
  6. */
  7. #include "scan.h"
  8. #include "bcma_private.h"
  9. #include <linux/bcma/bcma.h>
  10. #include <linux/bcma/bcma_regs.h>
  11. #include <linux/pci.h>
  12. #include <linux/io.h>
  13. #include <linux/dma-mapping.h>
  14. #include <linux/slab.h>
  15. struct bcma_device_id_name {
  16. u16 id;
  17. const char *name;
  18. };
  19. static const struct bcma_device_id_name bcma_arm_device_names[] = {
  20. { BCMA_CORE_4706_MAC_GBIT_COMMON, "BCM4706 GBit MAC Common" },
  21. { BCMA_CORE_ARM_1176, "ARM 1176" },
  22. { BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
  23. { BCMA_CORE_ARM_CM3, "ARM CM3" },
  24. };
  25. static const struct bcma_device_id_name bcma_bcm_device_names[] = {
  26. { BCMA_CORE_OOB_ROUTER, "OOB Router" },
  27. { BCMA_CORE_4706_CHIPCOMMON, "BCM4706 ChipCommon" },
  28. { BCMA_CORE_4706_SOC_RAM, "BCM4706 SOC RAM" },
  29. { BCMA_CORE_4706_MAC_GBIT, "BCM4706 GBit MAC" },
  30. { BCMA_CORE_NS_PCIEG2, "PCIe Gen 2" },
  31. { BCMA_CORE_NS_DMA, "DMA" },
  32. { BCMA_CORE_NS_SDIO3, "SDIO3" },
  33. { BCMA_CORE_NS_USB20, "USB 2.0" },
  34. { BCMA_CORE_NS_USB30, "USB 3.0" },
  35. { BCMA_CORE_NS_A9JTAG, "ARM Cortex A9 JTAG" },
  36. { BCMA_CORE_NS_DDR23, "Denali DDR2/DDR3 memory controller" },
  37. { BCMA_CORE_NS_ROM, "ROM" },
  38. { BCMA_CORE_NS_NAND, "NAND flash controller" },
  39. { BCMA_CORE_NS_QSPI, "SPI flash controller" },
  40. { BCMA_CORE_NS_CHIPCOMMON_B, "Chipcommon B" },
  41. { BCMA_CORE_ARMCA9, "ARM Cortex A9 core (ihost)" },
  42. { BCMA_CORE_AMEMC, "AMEMC (DDR)" },
  43. { BCMA_CORE_ALTA, "ALTA (I2S)" },
  44. { BCMA_CORE_INVALID, "Invalid" },
  45. { BCMA_CORE_CHIPCOMMON, "ChipCommon" },
  46. { BCMA_CORE_ILINE20, "ILine 20" },
  47. { BCMA_CORE_SRAM, "SRAM" },
  48. { BCMA_CORE_SDRAM, "SDRAM" },
  49. { BCMA_CORE_PCI, "PCI" },
  50. { BCMA_CORE_ETHERNET, "Fast Ethernet" },
  51. { BCMA_CORE_V90, "V90" },
  52. { BCMA_CORE_USB11_HOSTDEV, "USB 1.1 Hostdev" },
  53. { BCMA_CORE_ADSL, "ADSL" },
  54. { BCMA_CORE_ILINE100, "ILine 100" },
  55. { BCMA_CORE_IPSEC, "IPSEC" },
  56. { BCMA_CORE_UTOPIA, "UTOPIA" },
  57. { BCMA_CORE_PCMCIA, "PCMCIA" },
  58. { BCMA_CORE_INTERNAL_MEM, "Internal Memory" },
  59. { BCMA_CORE_MEMC_SDRAM, "MEMC SDRAM" },
  60. { BCMA_CORE_OFDM, "OFDM" },
  61. { BCMA_CORE_EXTIF, "EXTIF" },
  62. { BCMA_CORE_80211, "IEEE 802.11" },
  63. { BCMA_CORE_PHY_A, "PHY A" },
  64. { BCMA_CORE_PHY_B, "PHY B" },
  65. { BCMA_CORE_PHY_G, "PHY G" },
  66. { BCMA_CORE_USB11_HOST, "USB 1.1 Host" },
  67. { BCMA_CORE_USB11_DEV, "USB 1.1 Device" },
  68. { BCMA_CORE_USB20_HOST, "USB 2.0 Host" },
  69. { BCMA_CORE_USB20_DEV, "USB 2.0 Device" },
  70. { BCMA_CORE_SDIO_HOST, "SDIO Host" },
  71. { BCMA_CORE_ROBOSWITCH, "Roboswitch" },
  72. { BCMA_CORE_PARA_ATA, "PATA" },
  73. { BCMA_CORE_SATA_XORDMA, "SATA XOR-DMA" },
  74. { BCMA_CORE_ETHERNET_GBIT, "GBit Ethernet" },
  75. { BCMA_CORE_PCIE, "PCIe" },
  76. { BCMA_CORE_PHY_N, "PHY N" },
  77. { BCMA_CORE_SRAM_CTL, "SRAM Controller" },
  78. { BCMA_CORE_MINI_MACPHY, "Mini MACPHY" },
  79. { BCMA_CORE_PHY_LP, "PHY LP" },
  80. { BCMA_CORE_PMU, "PMU" },
  81. { BCMA_CORE_PHY_SSN, "PHY SSN" },
  82. { BCMA_CORE_SDIO_DEV, "SDIO Device" },
  83. { BCMA_CORE_PHY_HT, "PHY HT" },
  84. { BCMA_CORE_MAC_GBIT, "GBit MAC" },
  85. { BCMA_CORE_DDR12_MEM_CTL, "DDR1/DDR2 Memory Controller" },
  86. { BCMA_CORE_PCIE_RC, "PCIe Root Complex" },
  87. { BCMA_CORE_OCP_OCP_BRIDGE, "OCP to OCP Bridge" },
  88. { BCMA_CORE_SHARED_COMMON, "Common Shared" },
  89. { BCMA_CORE_OCP_AHB_BRIDGE, "OCP to AHB Bridge" },
  90. { BCMA_CORE_SPI_HOST, "SPI Host" },
  91. { BCMA_CORE_I2S, "I2S" },
  92. { BCMA_CORE_SDR_DDR1_MEM_CTL, "SDR/DDR1 Memory Controller" },
  93. { BCMA_CORE_SHIM, "SHIM" },
  94. { BCMA_CORE_PCIE2, "PCIe Gen2" },
  95. { BCMA_CORE_ARM_CR4, "ARM CR4" },
  96. { BCMA_CORE_GCI, "GCI" },
  97. { BCMA_CORE_CMEM, "CNDS DDR2/3 memory controller" },
  98. { BCMA_CORE_ARM_CA7, "ARM CA7" },
  99. { BCMA_CORE_DEFAULT, "Default" },
  100. };
  101. static const struct bcma_device_id_name bcma_mips_device_names[] = {
  102. { BCMA_CORE_MIPS, "MIPS" },
  103. { BCMA_CORE_MIPS_3302, "MIPS 3302" },
  104. { BCMA_CORE_MIPS_74K, "MIPS 74K" },
  105. };
  106. static const char *bcma_device_name(const struct bcma_device_id *id)
  107. {
  108. const struct bcma_device_id_name *names;
  109. int size, i;
  110. /* search manufacturer specific names */
  111. switch (id->manuf) {
  112. case BCMA_MANUF_ARM:
  113. names = bcma_arm_device_names;
  114. size = ARRAY_SIZE(bcma_arm_device_names);
  115. break;
  116. case BCMA_MANUF_BCM:
  117. names = bcma_bcm_device_names;
  118. size = ARRAY_SIZE(bcma_bcm_device_names);
  119. break;
  120. case BCMA_MANUF_MIPS:
  121. names = bcma_mips_device_names;
  122. size = ARRAY_SIZE(bcma_mips_device_names);
  123. break;
  124. default:
  125. return "UNKNOWN";
  126. }
  127. for (i = 0; i < size; i++) {
  128. if (names[i].id == id->id)
  129. return names[i].name;
  130. }
  131. return "UNKNOWN";
  132. }
  133. static u32 bcma_scan_read32(struct bcma_bus *bus, u8 current_coreidx,
  134. u16 offset)
  135. {
  136. return readl(bus->mmio + offset);
  137. }
  138. static void bcma_scan_switch_core(struct bcma_bus *bus, u32 addr)
  139. {
  140. if (bus->hosttype == BCMA_HOSTTYPE_PCI)
  141. pci_write_config_dword(bus->host_pci, BCMA_PCI_BAR0_WIN,
  142. addr);
  143. }
  144. static u32 bcma_erom_get_ent(struct bcma_bus *bus, u32 __iomem **eromptr)
  145. {
  146. u32 ent = readl(*eromptr);
  147. (*eromptr)++;
  148. return ent;
  149. }
  150. static void bcma_erom_push_ent(u32 __iomem **eromptr)
  151. {
  152. (*eromptr)--;
  153. }
  154. static s32 bcma_erom_get_ci(struct bcma_bus *bus, u32 __iomem **eromptr)
  155. {
  156. u32 ent = bcma_erom_get_ent(bus, eromptr);
  157. if (!(ent & SCAN_ER_VALID))
  158. return -ENOENT;
  159. if ((ent & SCAN_ER_TAG) != SCAN_ER_TAG_CI)
  160. return -ENOENT;
  161. return ent;
  162. }
  163. static bool bcma_erom_is_end(struct bcma_bus *bus, u32 __iomem **eromptr)
  164. {
  165. u32 ent = bcma_erom_get_ent(bus, eromptr);
  166. bcma_erom_push_ent(eromptr);
  167. return (ent == (SCAN_ER_TAG_END | SCAN_ER_VALID));
  168. }
  169. static bool bcma_erom_is_bridge(struct bcma_bus *bus, u32 __iomem **eromptr)
  170. {
  171. u32 ent = bcma_erom_get_ent(bus, eromptr);
  172. bcma_erom_push_ent(eromptr);
  173. return (((ent & SCAN_ER_VALID)) &&
  174. ((ent & SCAN_ER_TAGX) == SCAN_ER_TAG_ADDR) &&
  175. ((ent & SCAN_ADDR_TYPE) == SCAN_ADDR_TYPE_BRIDGE));
  176. }
  177. static void bcma_erom_skip_component(struct bcma_bus *bus, u32 __iomem **eromptr)
  178. {
  179. u32 ent;
  180. while (1) {
  181. ent = bcma_erom_get_ent(bus, eromptr);
  182. if ((ent & SCAN_ER_VALID) &&
  183. ((ent & SCAN_ER_TAG) == SCAN_ER_TAG_CI))
  184. break;
  185. if (ent == (SCAN_ER_TAG_END | SCAN_ER_VALID))
  186. break;
  187. }
  188. bcma_erom_push_ent(eromptr);
  189. }
  190. static s32 bcma_erom_get_mst_port(struct bcma_bus *bus, u32 __iomem **eromptr)
  191. {
  192. u32 ent = bcma_erom_get_ent(bus, eromptr);
  193. if (!(ent & SCAN_ER_VALID))
  194. return -ENOENT;
  195. if ((ent & SCAN_ER_TAG) != SCAN_ER_TAG_MP)
  196. return -ENOENT;
  197. return ent;
  198. }
  199. static u32 bcma_erom_get_addr_desc(struct bcma_bus *bus, u32 __iomem **eromptr,
  200. u32 type, u8 port)
  201. {
  202. u32 addrl;
  203. u32 size;
  204. u32 ent = bcma_erom_get_ent(bus, eromptr);
  205. if ((!(ent & SCAN_ER_VALID)) ||
  206. ((ent & SCAN_ER_TAGX) != SCAN_ER_TAG_ADDR) ||
  207. ((ent & SCAN_ADDR_TYPE) != type) ||
  208. (((ent & SCAN_ADDR_PORT) >> SCAN_ADDR_PORT_SHIFT) != port)) {
  209. bcma_erom_push_ent(eromptr);
  210. return (u32)-EINVAL;
  211. }
  212. addrl = ent & SCAN_ADDR_ADDR;
  213. if (ent & SCAN_ADDR_AG32)
  214. bcma_erom_get_ent(bus, eromptr);
  215. if ((ent & SCAN_ADDR_SZ) == SCAN_ADDR_SZ_SZD) {
  216. size = bcma_erom_get_ent(bus, eromptr);
  217. if (size & SCAN_SIZE_SG32)
  218. bcma_erom_get_ent(bus, eromptr);
  219. }
  220. return addrl;
  221. }
  222. static struct bcma_device *bcma_find_core_by_index(struct bcma_bus *bus,
  223. u16 index)
  224. {
  225. struct bcma_device *core;
  226. list_for_each_entry(core, &bus->cores, list) {
  227. if (core->core_index == index)
  228. return core;
  229. }
  230. return NULL;
  231. }
  232. static struct bcma_device *bcma_find_core_reverse(struct bcma_bus *bus, u16 coreid)
  233. {
  234. struct bcma_device *core;
  235. list_for_each_entry_reverse(core, &bus->cores, list) {
  236. if (core->id.id == coreid)
  237. return core;
  238. }
  239. return NULL;
  240. }
  241. #define IS_ERR_VALUE_U32(x) ((x) >= (u32)-MAX_ERRNO)
  242. static int bcma_get_next_core(struct bcma_bus *bus, u32 __iomem **eromptr,
  243. struct bcma_device_id *match, int core_num,
  244. struct bcma_device *core)
  245. {
  246. u32 tmp;
  247. u8 i, j, k;
  248. s32 cia, cib;
  249. u8 ports[2], wrappers[2];
  250. /* get CIs */
  251. cia = bcma_erom_get_ci(bus, eromptr);
  252. if (cia < 0) {
  253. bcma_erom_push_ent(eromptr);
  254. if (bcma_erom_is_end(bus, eromptr))
  255. return -ESPIPE;
  256. return -EILSEQ;
  257. }
  258. cib = bcma_erom_get_ci(bus, eromptr);
  259. if (cib < 0)
  260. return -EILSEQ;
  261. /* parse CIs */
  262. core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
  263. core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
  264. core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
  265. ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
  266. ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
  267. wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
  268. wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
  269. core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
  270. if (((core->id.manuf == BCMA_MANUF_ARM) &&
  271. (core->id.id == 0xFFF)) ||
  272. (ports[1] == 0)) {
  273. bcma_erom_skip_component(bus, eromptr);
  274. return -ENXIO;
  275. }
  276. /* check if component is a core at all */
  277. if (wrappers[0] + wrappers[1] == 0) {
  278. /* Some specific cores don't need wrappers */
  279. switch (core->id.id) {
  280. case BCMA_CORE_4706_MAC_GBIT_COMMON:
  281. case BCMA_CORE_NS_CHIPCOMMON_B:
  282. case BCMA_CORE_PMU:
  283. case BCMA_CORE_GCI:
  284. /* Not used yet: case BCMA_CORE_OOB_ROUTER: */
  285. break;
  286. default:
  287. bcma_erom_skip_component(bus, eromptr);
  288. return -ENXIO;
  289. }
  290. }
  291. if (bcma_erom_is_bridge(bus, eromptr)) {
  292. bcma_erom_skip_component(bus, eromptr);
  293. return -ENXIO;
  294. }
  295. if (bcma_find_core_by_index(bus, core_num)) {
  296. bcma_erom_skip_component(bus, eromptr);
  297. return -ENODEV;
  298. }
  299. if (match && ((match->manuf != BCMA_ANY_MANUF &&
  300. match->manuf != core->id.manuf) ||
  301. (match->id != BCMA_ANY_ID && match->id != core->id.id) ||
  302. (match->rev != BCMA_ANY_REV && match->rev != core->id.rev) ||
  303. (match->class != BCMA_ANY_CLASS && match->class != core->id.class)
  304. )) {
  305. bcma_erom_skip_component(bus, eromptr);
  306. return -ENODEV;
  307. }
  308. /* get & parse master ports */
  309. for (i = 0; i < ports[0]; i++) {
  310. s32 mst_port_d = bcma_erom_get_mst_port(bus, eromptr);
  311. if (mst_port_d < 0)
  312. return -EILSEQ;
  313. }
  314. /* First Slave Address Descriptor should be port 0:
  315. * the main register space for the core
  316. */
  317. tmp = bcma_erom_get_addr_desc(bus, eromptr, SCAN_ADDR_TYPE_SLAVE, 0);
  318. if (tmp == 0 || IS_ERR_VALUE_U32(tmp)) {
  319. /* Try again to see if it is a bridge */
  320. tmp = bcma_erom_get_addr_desc(bus, eromptr,
  321. SCAN_ADDR_TYPE_BRIDGE, 0);
  322. if (tmp == 0 || IS_ERR_VALUE_U32(tmp)) {
  323. return -EILSEQ;
  324. } else {
  325. bcma_info(bus, "Bridge found\n");
  326. return -ENXIO;
  327. }
  328. }
  329. core->addr = tmp;
  330. /* get & parse slave ports */
  331. k = 0;
  332. for (i = 0; i < ports[1]; i++) {
  333. for (j = 0; ; j++) {
  334. tmp = bcma_erom_get_addr_desc(bus, eromptr,
  335. SCAN_ADDR_TYPE_SLAVE, i);
  336. if (IS_ERR_VALUE_U32(tmp)) {
  337. /* no more entries for port _i_ */
  338. /* pr_debug("erom: slave port %d "
  339. * "has %d descriptors\n", i, j); */
  340. break;
  341. } else if (k < ARRAY_SIZE(core->addr_s)) {
  342. core->addr_s[k] = tmp;
  343. k++;
  344. }
  345. }
  346. }
  347. /* get & parse master wrappers */
  348. for (i = 0; i < wrappers[0]; i++) {
  349. for (j = 0; ; j++) {
  350. tmp = bcma_erom_get_addr_desc(bus, eromptr,
  351. SCAN_ADDR_TYPE_MWRAP, i);
  352. if (IS_ERR_VALUE_U32(tmp)) {
  353. /* no more entries for port _i_ */
  354. /* pr_debug("erom: master wrapper %d "
  355. * "has %d descriptors\n", i, j); */
  356. break;
  357. } else {
  358. if (i == 0 && j == 0)
  359. core->wrap = tmp;
  360. }
  361. }
  362. }
  363. /* get & parse slave wrappers */
  364. for (i = 0; i < wrappers[1]; i++) {
  365. u8 hack = (ports[1] == 1) ? 0 : 1;
  366. for (j = 0; ; j++) {
  367. tmp = bcma_erom_get_addr_desc(bus, eromptr,
  368. SCAN_ADDR_TYPE_SWRAP, i + hack);
  369. if (IS_ERR_VALUE_U32(tmp)) {
  370. /* no more entries for port _i_ */
  371. /* pr_debug("erom: master wrapper %d "
  372. * has %d descriptors\n", i, j); */
  373. break;
  374. } else {
  375. if (wrappers[0] == 0 && !i && !j)
  376. core->wrap = tmp;
  377. }
  378. }
  379. }
  380. if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
  381. core->io_addr = ioremap(core->addr, BCMA_CORE_SIZE);
  382. if (!core->io_addr)
  383. return -ENOMEM;
  384. if (core->wrap) {
  385. core->io_wrap = ioremap(core->wrap,
  386. BCMA_CORE_SIZE);
  387. if (!core->io_wrap) {
  388. iounmap(core->io_addr);
  389. return -ENOMEM;
  390. }
  391. }
  392. }
  393. return 0;
  394. }
  395. void bcma_detect_chip(struct bcma_bus *bus)
  396. {
  397. s32 tmp;
  398. struct bcma_chipinfo *chipinfo = &(bus->chipinfo);
  399. char chip_id[8];
  400. bcma_scan_switch_core(bus, BCMA_ADDR_BASE);
  401. tmp = bcma_scan_read32(bus, 0, BCMA_CC_ID);
  402. chipinfo->id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
  403. chipinfo->rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
  404. chipinfo->pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
  405. snprintf(chip_id, ARRAY_SIZE(chip_id),
  406. (chipinfo->id > 0x9999) ? "%d" : "0x%04X", chipinfo->id);
  407. bcma_info(bus, "Found chip with id %s, rev 0x%02X and package 0x%02X\n",
  408. chip_id, chipinfo->rev, chipinfo->pkg);
  409. }
  410. int bcma_bus_scan(struct bcma_bus *bus)
  411. {
  412. u32 erombase;
  413. u32 __iomem *eromptr, *eromend;
  414. int err, core_num = 0;
  415. /* Skip if bus was already scanned (e.g. during early register) */
  416. if (bus->nr_cores)
  417. return 0;
  418. erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
  419. if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
  420. eromptr = ioremap(erombase, BCMA_CORE_SIZE);
  421. if (!eromptr)
  422. return -ENOMEM;
  423. } else {
  424. eromptr = bus->mmio;
  425. }
  426. eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
  427. bcma_scan_switch_core(bus, erombase);
  428. while (eromptr < eromend) {
  429. struct bcma_device *other_core;
  430. struct bcma_device *core = kzalloc(sizeof(*core), GFP_KERNEL);
  431. if (!core) {
  432. err = -ENOMEM;
  433. goto out;
  434. }
  435. INIT_LIST_HEAD(&core->list);
  436. core->bus = bus;
  437. err = bcma_get_next_core(bus, &eromptr, NULL, core_num, core);
  438. if (err < 0) {
  439. kfree(core);
  440. if (err == -ENODEV) {
  441. core_num++;
  442. continue;
  443. } else if (err == -ENXIO) {
  444. continue;
  445. } else if (err == -ESPIPE) {
  446. break;
  447. }
  448. goto out;
  449. }
  450. core->core_index = core_num++;
  451. bus->nr_cores++;
  452. other_core = bcma_find_core_reverse(bus, core->id.id);
  453. core->core_unit = (other_core == NULL) ? 0 : other_core->core_unit + 1;
  454. bcma_prepare_core(bus, core);
  455. bcma_info(bus, "Core %d found: %s (manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
  456. core->core_index, bcma_device_name(&core->id),
  457. core->id.manuf, core->id.id, core->id.rev,
  458. core->id.class);
  459. list_add_tail(&core->list, &bus->cores);
  460. }
  461. err = 0;
  462. out:
  463. if (bus->hosttype == BCMA_HOSTTYPE_SOC)
  464. iounmap(eromptr);
  465. return err;
  466. }