开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ip27-init.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ip27-init.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General
  3.  * Public License.  See the file "COPYING" in the main directory of this
  4.  * archive for more details.
  5.  *
  6.  * Copyright (C) 2000 - 2001 by Kanoj Sarcar (kanoj@sgi.com)
  7.  * Copyright (C) 2000 - 2001 by Silicon Graphics, Inc.
  8.  */
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/init.h>
  13. #include <linux/sched.h>
  14. #include <linux/mmzone.h> /* for numnodes */
  15. #include <linux/mm.h>
  16. #include <asm/pgalloc.h>
  17. #include <asm/pgtable.h>
  18. #include <asm/sn/types.h>
  19. #include <asm/sn/sn0/addrs.h>
  20. #include <asm/sn/sn0/hubni.h>
  21. #include <asm/sn/sn0/hubio.h>
  22. #include <asm/sn/klconfig.h>
  23. #include <asm/sn/ioc3.h>
  24. #include <asm/mipsregs.h>
  25. #include <asm/sn/gda.h>
  26. #include <asm/sn/intr.h>
  27. #include <asm/current.h>
  28. #include <asm/smp.h>
  29. #include <asm/processor.h>
  30. #include <asm/mmu_context.h>
  31. #include <asm/sn/launch.h>
  32. #include <asm/sn/sn_private.h>
  33. #include <asm/sn/sn0/ip27.h>
  34. #include <asm/sn/mapped_kernel.h>
  35. #include <asm/sn/sn0/addrs.h>
  36. #include <asm/sn/gda.h>
  38. #define CPU_NONE (cpuid_t)-1
  40. /*
  41.  * The following should work till 64 nodes, ie 128p SN0s.
  42.  */
  43. #define CNODEMASK_CLRALL(p) (p) = 0
  44. #define CNODEMASK_TSTB(p, bit) ((p) & (1ULL << (bit)))
  45. #define CNODEMASK_SETB(p, bit) ((p) |= 1ULL << (bit))
  47. cpumask_t boot_cpumask;
  48. hubreg_t region_mask = 0;
  49. static int fine_mode = 0;
  50. int maxcpus;
  51. static spinlock_t hub_mask_lock = SPIN_LOCK_UNLOCKED;
  52. static cnodemask_t hub_init_mask;
  53. static atomic_t numstarted = ATOMIC_INIT(1);
  54. static int router_distance;
  55. nasid_t master_nasid = INVALID_NASID;
  57. cnodeid_t nasid_to_compact_node[MAX_NASIDS];
  58. nasid_t compact_to_nasid_node[MAX_COMPACT_NODES];
  59. cnodeid_t cpuid_to_compact_node[MAXCPUS];
  60. char node_distances[MAX_COMPACT_NODES][MAX_COMPACT_NODES];
  62. hubreg_t get_region(cnodeid_t cnode)
  63. {
  64. if (fine_mode)
  65. return COMPACT_TO_NASID_NODEID(cnode) >> NASID_TO_FINEREG_SHFT;
  66. else
  67. return COMPACT_TO_NASID_NODEID(cnode) >> NASID_TO_COARSEREG_SHFT;
  68. }
  70. static void gen_region_mask(hubreg_t *region_mask, int maxnodes)
  71. {
  72. cnodeid_t cnode;
  74. (*region_mask) = 0;
  75. for (cnode = 0; cnode < maxnodes; cnode++) {
  76. (*region_mask) |= 1ULL << get_region(cnode);
  77. }
  78. }
  80. int is_fine_dirmode(void)
  81. {
  82. return (((LOCAL_HUB_L(NI_STATUS_REV_ID) & NSRI_REGIONSIZE_MASK)
  83. >> NSRI_REGIONSIZE_SHFT) & REGIONSIZE_FINE);
  84. }
  86. nasid_t get_actual_nasid(lboard_t *brd)
  87. {
  88. klhub_t *hub;
  90. if (!brd)
  91. return INVALID_NASID;
  93. /* find out if we are a completely disabled brd. */
  94. hub  = (klhub_t *)find_first_component(brd, KLSTRUCT_HUB);
  95. if (!hub)
  96. return INVALID_NASID;
  97. if (!(hub->hub_info.flags & KLINFO_ENABLE)) /* disabled node brd */
  98. return hub->hub_info.physid;
  99. else
  100. return brd->brd_nasid;
  101. }
  103. /* Tweak this for maximum number of CPUs to activate */
  104. static int max_cpus = NR_CPUS;
  106. int do_cpumask(cnodeid_t cnode, nasid_t nasid, cpumask_t *boot_cpumask, 
  107. int *highest)
  108. {
  109. static int tot_cpus_found = 0;
  110. lboard_t *brd;
  111. klcpu_t *acpu;
  112. int cpus_found = 0;
  113. cpuid_t cpuid;
  115. brd = find_lboard((lboard_t *)KL_CONFIG_INFO(nasid), KLTYPE_IP27);
  117. do {
  118. acpu = (klcpu_t *)find_first_component(brd, KLSTRUCT_CPU);
  119. while (acpu) {
  120. cpuid = acpu->cpu_info.virtid;
  121. /* cnode is not valid for completely disabled brds */
  122. if (get_actual_nasid(brd) == brd->brd_nasid)
  123. cpuid_to_compact_node[cpuid] = cnode;
  124. if (cpuid > *highest)
  125. *highest = cpuid;
  126. /* Only let it join in if it's marked enabled */
  127. if ((acpu->cpu_info.flags & KLINFO_ENABLE) &&
  128. (tot_cpus_found != max_cpus)) {
  129. CPUMASK_SETB(*boot_cpumask, cpuid);
  130. cpus_found++;
  131. tot_cpus_found++;
  132. }
  133. acpu = (klcpu_t *)find_component(brd, (klinfo_t *)acpu, 
  134. KLSTRUCT_CPU);
  135. }
  136. brd = KLCF_NEXT(brd);
  137. if (brd)
  138. brd = find_lboard(brd,KLTYPE_IP27);
  139. else
  140. break;
  141. } while (brd);
  143. return cpus_found;
  144. }
  146. cpuid_t cpu_node_probe(cpumask_t *boot_cpumask, int *numnodes)
  147. {
  148. int i, cpus = 0, highest = 0;
  149. gda_t *gdap = GDA;
  150. nasid_t nasid;
  152. /*
  153.  * Initialize the arrays to invalid nodeid (-1)
  154.  */
  155. for (i = 0; i < MAX_COMPACT_NODES; i++)
  156. compact_to_nasid_node[i] = INVALID_NASID;
  157. for (i = 0; i < MAX_NASIDS; i++)
  158. nasid_to_compact_node[i] = INVALID_CNODEID;
  159. for (i = 0; i < MAXCPUS; i++)
  160. cpuid_to_compact_node[i] = INVALID_CNODEID;
  162. *numnodes = 0;
  163. for (i = 0; i < MAX_COMPACT_NODES; i++) {
  164. if ((nasid = gdap->g_nasidtable[i]) == INVALID_NASID) {
  165. break;
  166. } else {
  167. compact_to_nasid_node[i] = nasid;
  168. nasid_to_compact_node[nasid] = i;
  169. (*numnodes)++;
  170. cpus += do_cpumask(i, nasid, boot_cpumask, &highest);
  171. }
  172. }
  174. /*
  175.  * Cpus are numbered in order of cnodes. Currently, disabled
  176.  * cpus are not numbered.
  177.  */
  179. return(highest + 1);
  180. }
  182. int cpu_enabled(cpuid_t cpu)
  183. {
  184. if (cpu == CPU_NONE)
  185. return 0;
  186. return (CPUMASK_TSTB(boot_cpumask, cpu) != 0);
  187. }
  189. void mlreset (void)
  190. {
  191. int i;
  192. void init_topology_matrix(void);
  193. void dump_topology(void);
  196. master_nasid = get_nasid();
  197. fine_mode = is_fine_dirmode();
  199. /*
  200.  * Probe for all CPUs - this creates the cpumask and
  201.  * sets up the mapping tables.
  202.  */
  203. CPUMASK_CLRALL(boot_cpumask);
  204. maxcpus = cpu_node_probe(&boot_cpumask, &numnodes);
  205. printk("Discovered %d cpus on %d nodesn", maxcpus, numnodes);
  207. init_topology_matrix();
  208. dump_topology();
  210. gen_region_mask(&region_mask, numnodes);
  211. CNODEMASK_CLRALL(hub_init_mask);
  213. setup_replication_mask(numnodes);
  215. /*
  216.  * Set all nodes' calias sizes to 8k
  217.  */
  218. for (i = 0; i < numnodes; i++) {
  219. nasid_t nasid;
  221. nasid = COMPACT_TO_NASID_NODEID(i);
  223. /*
  224.  * Always have node 0 in the region mask, otherwise
  225.  * CALIAS accesses get exceptions since the hub
  226.  * thinks it is a node 0 address.
  227.  */
  228. REMOTE_HUB_S(nasid, PI_REGION_PRESENT, (region_mask | 1));
  229. #ifdef CONFIG_REPLICATE_EXHANDLERS
  230. REMOTE_HUB_S(nasid, PI_CALIAS_SIZE, PI_CALIAS_SIZE_8K);
  231. #else
  232. REMOTE_HUB_S(nasid, PI_CALIAS_SIZE, PI_CALIAS_SIZE_0);
  233. #endif
  235. #ifdef LATER
  236. /*
  237.  * Set up all hubs to have a big window pointing at
  238.  * widget 0. Memory mode, widget 0, offset 0
  239.  */
  240. REMOTE_HUB_S(nasid, IIO_ITTE(SWIN0_BIGWIN),
  241. ((HUB_PIO_MAP_TO_MEM << IIO_ITTE_IOSP_SHIFT) |
  242. (0 << IIO_ITTE_WIDGET_SHIFT)));
  243. #endif
  244. }
  245. }
  248. void intr_clear_bits(nasid_t nasid, volatile hubreg_t *pend, int base_level,
  249. char *name)
  250. {
  251. volatile hubreg_t bits;
  252. int i;
  254. /* Check pending interrupts */
  255. if ((bits = HUB_L(pend)) != 0)
  256. for (i = 0; i < N_INTPEND_BITS; i++)
  257. if (bits & (1 << i))
  258. LOCAL_HUB_CLR_INTR(base_level + i);
  259. }
  261. void intr_clear_all(nasid_t nasid)
  262. {
  263. REMOTE_HUB_S(nasid, PI_INT_MASK0_A, 0);
  264. REMOTE_HUB_S(nasid, PI_INT_MASK0_B, 0);
  265. REMOTE_HUB_S(nasid, PI_INT_MASK1_A, 0);
  266. REMOTE_HUB_S(nasid, PI_INT_MASK1_B, 0);
  267. intr_clear_bits(nasid, REMOTE_HUB_ADDR(nasid, PI_INT_PEND0),
  268. INT_PEND0_BASELVL, "INT_PEND0");
  269. intr_clear_bits(nasid, REMOTE_HUB_ADDR(nasid, PI_INT_PEND1),
  270. INT_PEND1_BASELVL, "INT_PEND1");
  271. }
  273. void sn_mp_setup(void)
  274. {
  275. cnodeid_t cnode;
  276. #if 0
  277. cpuid_t cpu;
  278. #endif
  280. for (cnode = 0; cnode < numnodes; cnode++) {
  281. #if 0
  282. init_platform_nodepda();
  283. #endif
  284. intr_clear_all(COMPACT_TO_NASID_NODEID(cnode));
  285. }
  286. #if 0
  287. for (cpu = 0; cpu < maxcpus; cpu++) {
  288. init_platform_pda();
  289. }
  290. #endif
  291. }
  293. void per_hub_init(cnodeid_t cnode)
  294. {
  295. extern void pcibr_setup(cnodeid_t);
  296. cnodemask_t done;
  297. nasid_t nasid;
  299. nasid = COMPACT_TO_NASID_NODEID(cnode);
  301. spin_lock(&hub_mask_lock);
  302. /* Test our bit. */
  303. if (!(done = CNODEMASK_TSTB(hub_init_mask, cnode))) {
  304. /* Turn our bit on in the mask. */
  305. CNODEMASK_SETB(hub_init_mask, cnode);
  306. /*
  307.    * Do the actual initialization if it hasn't been done yet.
  308.    * We don't need to hold a lock for this work.
  309.    */
  310. /*
  311.  * Set CRB timeout at 5ms, (< PI timeout of 10ms)
  312.  */
  313. REMOTE_HUB_S(nasid, IIO_ICTP, 0x800);
  314. REMOTE_HUB_S(nasid, IIO_ICTO, 0xff);
  315. hub_rtc_init(cnode);
  316. pcibr_setup(cnode); 
  317. #ifdef CONFIG_REPLICATE_EXHANDLERS
  318. /*
  319.  * If this is not a headless node initialization, 
  320.  * copy over the caliased exception handlers.
  321.  */
  322. if (get_compact_nodeid() == cnode) {
  323. extern char except_vec0, except_vec1_r10k;
  324. extern char except_vec2_generic, except_vec3_generic;
  326. memcpy((void *)(KSEG0 + 0x100), &except_vec2_generic,
  327. 0x80);
  328. memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic,
  329. 0x80);
  330. memcpy((void *)KSEG0, &except_vec0, 0x80);
  331. memcpy((void *)KSEG0 + 0x080, &except_vec1_r10k, 0x80);
  332. memcpy((void *)(KSEG0 + 0x100), (void *) KSEG0, 0x80);
  333. memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic,
  334. 0x100);
  335. flush_cache_l1();
  336. flush_cache_l2();
  337. }
  338. #endif
  339. }
  340. spin_unlock(&hub_mask_lock);
  341. }
  343. /*
  344.  * This is similar to hard_smp_processor_id().
  345.  */
  346. cpuid_t getcpuid(void)
  347. {
  348. klcpu_t *klcpu;
  350. klcpu = nasid_slice_to_cpuinfo(get_nasid(),LOCAL_HUB_L(PI_CPU_NUM));
  351. return klcpu->cpu_info.virtid;
  352. }
  354. void per_cpu_init(void)
  355. {
  356. extern void install_cpu_nmi_handler(int slice);
  357. extern void load_mmu(void);
  358. static int is_slave = 0;
  359. int cpu = smp_processor_id();
  360. cnodeid_t cnode = get_compact_nodeid();
  362. current_cpu_data.asid_cache = ASID_FIRST_VERSION;
  363. TLBMISS_HANDLER_SETUP();
  364. #if 0
  365. intr_init();
  366. #endif
  367. set_cp0_status(ST0_IM, 0);
  368. per_hub_init(cnode);
  369. cpu_time_init();
  370. if (smp_processor_id()) /* master can't do this early, no kmalloc */
  371. install_cpuintr(cpu);
  372. /* Install our NMI handler if symmon hasn't installed one. */
  373. install_cpu_nmi_handler(cputoslice(cpu));
  374. #if 0
  375. install_tlbintr(cpu);
  376. #endif
  377. set_cp0_status(SRB_DEV0 | SRB_DEV1, SRB_DEV0 | SRB_DEV1);
  378. if (is_slave) {
  379. set_cp0_status(ST0_BEV, 0);
  380. if (mips4_available)
  381. set_cp0_status(ST0_XX, ST0_XX);
  382. set_cp0_status(ST0_KX|ST0_SX|ST0_UX, ST0_KX|ST0_SX|ST0_UX);
  383. sti();
  384. load_mmu();
  385. atomic_inc(&numstarted);
  386. } else {
  387. is_slave = 1;
  388. }
  389. }
  391. cnodeid_t get_compact_nodeid(void)
  392. {
  393. nasid_t nasid;
  395. nasid = get_nasid();
  396. /*
  397.  * Map the physical node id to a virtual node id (virtual node ids
  398.  * are contiguous).
  399.  */
  400. return NASID_TO_COMPACT_NODEID(nasid);
  401. }
  403. #ifdef CONFIG_SMP
  405. /*
  406.  * Takes as first input the PROM assigned cpu id, and the kernel
  407.  * assigned cpu id as the second.
  408.  */
  409. static void alloc_cpupda(cpuid_t cpu, int cpunum)
  410. {
  411. cnodeid_t node;
  412. nasid_t nasid;
  414. node = get_cpu_cnode(cpu);
  415. nasid = COMPACT_TO_NASID_NODEID(node);
  417. cputonasid(cpunum) = nasid;
  418. cputocnode(cpunum) = node;
  419. cputoslice(cpunum) = get_cpu_slice(cpu);
  420. cpu_data[cpunum].p_cpuid = cpu;
  421. }
  423. void __init smp_callin(void)
  424. {
  425. #if 0
  426. calibrate_delay();
  427. smp_store_cpu_info(cpuid);
  428. #endif
  429. }
  431. int __init start_secondary(void)
  432. {
  433. extern int cpu_idle(void);
  434. extern atomic_t smp_commenced;
  436. smp_callin();
  437. while (!atomic_read(&smp_commenced));
  438. return cpu_idle();
  439. }
  441. static volatile cpumask_t boot_barrier;
  443. void cboot(void)
  444. {
  445. CPUMASK_CLRB(boot_barrier, getcpuid()); /* needs atomicity */
  446. per_cpu_init();
  447. #if 0
  448. ecc_init();
  449. bte_lateinit();
  450. init_mfhi_war();
  451. #endif
  452. _flush_tlb_all();
  453. flush_cache_l1();
  454. flush_cache_l2();
  455. start_secondary();
  456. }
  458. void allowboot(void)
  459. {
  460. int num_cpus = 0;
  461. cpuid_t cpu, mycpuid = getcpuid();
  462. cnodeid_t cnode;
  463. extern void bootstrap(void);
  465. sn_mp_setup();
  466. /* Master has already done per_cpu_init() */
  467. install_cpuintr(smp_processor_id());
  468. #if 0
  469. bte_lateinit();
  470. ecc_init();
  471. #endif
  473. replicate_kernel_text(numnodes);
  474. boot_barrier = boot_cpumask;
  475. /* Launch slaves. */
  476. for (cpu = 0; cpu < maxcpus; cpu++) {
  477. if (cpu == mycpuid) {
  478. alloc_cpupda(cpu, num_cpus);
  479. num_cpus++;
  480. /* We're already started, clear our bit */
  481. CPUMASK_CLRB(boot_barrier, cpu);
  482. continue;
  483. }
  485. /* Skip holes in CPU space */
  486. if (CPUMASK_TSTB(boot_cpumask, cpu)) {
  487. struct task_struct *p;
  489. /*
  490.  * The following code is purely to make sure
  491.  * Linux can schedule processes on this slave.
  492.  */
  493. kernel_thread(0, NULL, CLONE_PID);
  494. p = init_task.prev_task;
  495. sprintf(p->comm, "%s%d", "Idle", num_cpus);
  496. init_tasks[num_cpus] = p;
  497. alloc_cpupda(cpu, num_cpus);
  498. del_from_runqueue(p);
  499. p->processor = num_cpus;
  500. p->cpus_runnable = 1 << num_cpus; /* we schedule the first task manually */
  501. unhash_process(p);
  502. /* Attach to the address space of init_task. */
  503. atomic_inc(&init_mm.mm_count);
  504. p->active_mm = &init_mm;
  506. /*
  507.    * Launch a slave into bootstrap().
  508.    * It doesn't take an argument, and we
  509.  * set sp to the kernel stack of the newly 
  510.  * created idle process, gp to the proc struct
  511.  * (so that current-> works).
  512.    */
  513. LAUNCH_SLAVE(cputonasid(num_cpus),cputoslice(num_cpus), 
  514. (launch_proc_t)MAPPED_KERN_RW_TO_K0(bootstrap),
  515. 0, (void *)((unsigned long)p + 
  516. KERNEL_STACK_SIZE - 32), (void *)p);
  518. /*
  519.  * Now optimistically set the mapping arrays. We
  520.  * need to wait here, verify the cpu booted up, then
  521.  * fire up the next cpu.
  522.  */
  523. __cpu_number_map[cpu] = num_cpus;
  524. __cpu_logical_map[num_cpus] = cpu;
  525. num_cpus++;
  526. /*
  527.  * Wait this cpu to start up and initialize its hub,
  528.  * and discover the io devices it will control.
  529.  * 
  530.  * XXX: We really want to fire up launch all the CPUs
  531.  * at once.  We have to preserve the order of the
  532.  * devices on the bridges first though.
  533.  */
  534. while(atomic_read(&numstarted) != num_cpus);
  535. }
  536. }
  539. #ifdef LATER
  540. Wait logic goes here.
  541. #endif
  542. for (cnode = 0; cnode < numnodes; cnode++) {
  543. #if 0
  544. if (cnodetocpu(cnode) == -1) {
  545. printk("Initializing headless hub,cnode %d", cnode);
  546. per_hub_init(cnode);
  547. }
  548. #endif
  549. }
  550. #if 0
  551. cpu_io_setup();
  552. init_mfhi_war();
  553. #endif
  554. smp_num_cpus = num_cpus;
  555. }
  557. #else /* CONFIG_SMP */
  558. void cboot(void) {}
  559. #endif /* CONFIG_SMP */
  562. #define rou_rflag rou_flags
  564. void
  565. router_recurse(klrou_t *router_a, klrou_t *router_b, int depth)
  566. {
  567. klrou_t *router;
  568. lboard_t *brd;
  569. int port;
  571. if (router_a->rou_rflag == 1)
  572. return;
  574. if (depth >= router_distance)
  575. return;
  577. router_a->rou_rflag = 1;
  579. for (port = 1; port <= MAX_ROUTER_PORTS; port++) {
  580. if (router_a->rou_port[port].port_nasid == INVALID_NASID)
  581. continue;
  583. brd = (lboard_t *)NODE_OFFSET_TO_K0(
  584. router_a->rou_port[port].port_nasid,
  585. router_a->rou_port[port].port_offset);
  587. if (brd->brd_type == KLTYPE_ROUTER) {
  588. router = (klrou_t *)NODE_OFFSET_TO_K0(NASID_GET(brd), brd->brd_compts[0]);
  589. if (router == router_b) {
  590. if (depth < router_distance)
  591. router_distance = depth;
  592. }
  593. else
  594. router_recurse(router, router_b, depth + 1);
  595. }
  596. }
  598. router_a->rou_rflag = 0;
  599. }
  601. int
  602. node_distance(nasid_t nasid_a, nasid_t nasid_b)
  603. {
  604. nasid_t nasid;
  605. cnodeid_t cnode;
  606. lboard_t *brd, *dest_brd;
  607. int port;
  608. klrou_t *router, *router_a = NULL, *router_b = NULL;
  610. /* Figure out which routers nodes in question are connected to */
  611. for (cnode = 0; cnode < numnodes; cnode++) {
  612. nasid = COMPACT_TO_NASID_NODEID(cnode);
  614. if (nasid == -1) continue;
  616. brd = find_lboard_class((lboard_t *)KL_CONFIG_INFO(nasid),
  617. KLTYPE_ROUTER);
  619. if (!brd)
  620. continue;
  622. do {
  623. if (brd->brd_flags & DUPLICATE_BOARD)
  624. continue;
  626. router = (klrou_t *)NODE_OFFSET_TO_K0(NASID_GET(brd), brd->brd_compts[0]);
  627. router->rou_rflag = 0;
  629. for (port = 1; port <= MAX_ROUTER_PORTS; port++) {
  630. if (router->rou_port[port].port_nasid == INVALID_NASID)
  631. continue;
  633. dest_brd = (lboard_t *)NODE_OFFSET_TO_K0(
  634. router->rou_port[port].port_nasid,
  635. router->rou_port[port].port_offset);
  637. if (dest_brd->brd_type == KLTYPE_IP27) {
  638. if (dest_brd->brd_nasid == nasid_a)
  639. router_a = router;
  640. if (dest_brd->brd_nasid == nasid_b)
  641. router_b = router;
  642. }
  643. }
  645. } while ( (brd = find_lboard_class(KLCF_NEXT(brd), KLTYPE_ROUTER)) );
  646. }
  648. if (router_a == NULL) {
  649. printk("node_distance: router_a NULLn");
  650. return -1;
  651. }
  652. if (router_b == NULL) {
  653. printk("node_distance: router_b NULLn");
  654. return -1;
  655. }
  657. if (nasid_a == nasid_b)
  658. return 0;
  660. if (router_a == router_b)
  661. return 1;
  663. router_distance = 100;
  664. router_recurse(router_a, router_b, 2);
  666. return router_distance;
  667. }
  669. void
  670. init_topology_matrix(void)
  671. {
  672. nasid_t nasid, nasid2;
  673. cnodeid_t row, col;
  675. for (row = 0; row < MAX_COMPACT_NODES; row++)
  676. for (col = 0; col < MAX_COMPACT_NODES; col++)
  677. node_distances[row][col] = -1;
  679. for (row = 0; row < numnodes; row++) {
  680. nasid = COMPACT_TO_NASID_NODEID(row);
  681. for (col = 0; col < numnodes; col++) {
  682. nasid2 = COMPACT_TO_NASID_NODEID(col);
  683. node_distances[row][col] = node_distance(nasid, nasid2);
  684. }
  685. }
  686. }
  688. void
  689. dump_topology(void)
  690. {
  691. nasid_t nasid;
  692. cnodeid_t cnode;
  693. lboard_t *brd, *dest_brd;
  694. int port;
  695. int router_num = 0;
  696. klrou_t *router;
  697. cnodeid_t row, col;
  699. printk("************** Topology ********************n");
  701. printk("    ");
  702. for (col = 0; col < numnodes; col++)
  703. printk("%02d ", col);
  704. printk("n");
  705. for (row = 0; row < numnodes; row++) {
  706. printk("%02d  ", row);
  707. for (col = 0; col < numnodes; col++)
  708. printk("%2d ", node_distances[row][col]);
  709. printk("n");
  710. }
  712. for (cnode = 0; cnode < numnodes; cnode++) {
  713. nasid = COMPACT_TO_NASID_NODEID(cnode);
  715. if (nasid == -1) continue;
  717. brd = find_lboard_class((lboard_t *)KL_CONFIG_INFO(nasid),
  718. KLTYPE_ROUTER);
  720. if (!brd)
  721. continue;
  723. do {
  724. if (brd->brd_flags & DUPLICATE_BOARD)
  725. continue;
  726. printk("Router %d:", router_num);
  727. router_num++;
  729. router = (klrou_t *)NODE_OFFSET_TO_K0(NASID_GET(brd), brd->brd_compts[0]);
  731. for (port = 1; port <= MAX_ROUTER_PORTS; port++) {
  732. if (router->rou_port[port].port_nasid == INVALID_NASID)
  733. continue;
  735. dest_brd = (lboard_t *)NODE_OFFSET_TO_K0(
  736. router->rou_port[port].port_nasid,
  737. router->rou_port[port].port_offset);
  739. if (dest_brd->brd_type == KLTYPE_IP27)
  740. printk(" %d", dest_brd->brd_nasid);
  741. if (dest_brd->brd_type == KLTYPE_ROUTER)
  742. printk(" r");
  743. }
  744. printk("n");
  746. } while ( (brd = find_lboard_class(KLCF_NEXT(brd), KLTYPE_ROUTER)) );
  747. }
  748. }
  750. #if 0
  751. #define brd_widgetnum brd_slot
  752. #define NODE_OFFSET_TO_KLINFO(n,off)    ((klinfo_t*) TO_NODE_CAC(n,off))
  753. void
  754. dump_klcfg(void)
  755. {
  756. cnodeid_t       cnode;
  757. int i;
  758. nasid_t         nasid;
  759. lboard_t        *lbptr;
  760. gda_t           *gdap;
  762. gdap = (gda_t *)GDA_ADDR(get_nasid());
  763. if (gdap->g_magic != GDA_MAGIC) {
  764. printk("dumpklcfg_cmd: Invalid GDA MAGICn");
  765. return;
  766. }
  768. for (cnode = 0; cnode < MAX_COMPACT_NODES; cnode ++) {
  769. nasid = gdap->g_nasidtable[cnode];
  771. if (nasid == INVALID_NASID)
  772. continue;
  774. printk("nDumpping klconfig Nasid %d:n", nasid);
  776. lbptr = KL_CONFIG_INFO(nasid);
  778. while (lbptr) {
  779. printk("    %s, Nasid %d, Module %d, widget 0x%x, partition %d, NIC 0x%x lboard 0x%lx",
  780. "board name here", /* BOARD_NAME(lbptr->brd_type), */
  781. lbptr->brd_nasid, lbptr->brd_module, 
  782. lbptr->brd_widgetnum,
  783. lbptr->brd_partition, 
  784. (lbptr->brd_nic), lbptr);
  785. if (lbptr->brd_flags & DUPLICATE_BOARD)
  786. printk(" -D");
  787. printk("n");
  788. for (i = 0; i < lbptr->brd_numcompts; i++) {
  789. klinfo_t *kli;
  790. kli = NODE_OFFSET_TO_KLINFO(NASID_GET(lbptr), lbptr->brd_compts[i]);                       
  791. printk("        type %2d, flags 0x%04x, diagval %3d, physid %4d, virtid %2d: %sn", 
  792. kli->struct_type, 
  793. kli->flags,
  794. kli->diagval,
  795. kli->physid,
  796. kli->virtid,
  797. "comp. name here");
  798. /* COMPONENT_NAME(kli->struct_type)); */
  799. }
  800. lbptr = KLCF_NEXT(lbptr);
  801. }
  802. }
  803. printk("n");
  805. /* Useful to print router maps also */
  807. for (cnode = 0; cnode < MAX_COMPACT_NODES; cnode ++) {
  808. klrou_t *kr;
  809. int i;
  811.          nasid = gdap->g_nasidtable[cnode];
  812.          if (nasid == INVALID_NASID)
  813.              continue;
  814.          lbptr = KL_CONFIG_INFO(nasid);
  816.          while (lbptr) {
  818. lbptr = find_lboard_class(lbptr, KLCLASS_ROUTER);
  819. if(!lbptr)
  820. break;
  821. if (!KL_CONFIG_DUPLICATE_BOARD(lbptr)) {
  822. printk("%llx -> n", lbptr->brd_nic);
  823. kr = (klrou_t *)find_first_component(lbptr,
  824. KLSTRUCT_ROU);
  825. for (i = 1; i <= MAX_ROUTER_PORTS; i++) {
  826. printk("[%d, %llx]; ",
  827. kr->rou_port[i].port_nasid,
  828. kr->rou_port[i].port_offset);
  829. }
  830. printk("n");
  831. }
  832. lbptr = KLCF_NEXT(lbptr);
  833.          }
  834.          printk("n");
  835.      }
  837. dump_topology();
  838. }
  839. #endif