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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
smp.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

smp.c：源码内容
  1. /*
  2.  * 
  3.  *
  4.  * SMP support for ppc.
  5.  *
  6.  * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
  7.  * deal of code from the sparc and intel versions.
  8.  *
  9.  * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
  10.  *
  11.  * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
  12.  * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
  13.  *
  14.  *      This program is free software; you can redistribute it and/or
  15.  *      modify it under the terms of the GNU General Public License
  16.  *      as published by the Free Software Foundation; either version
  17.  *      2 of the License, or (at your option) any later version.
  18.  */
  20. #include <linux/config.h>
  21. #include <linux/kernel.h>
  22. #include <linux/sched.h>
  23. #include <linux/smp.h>
  24. #include <linux/smp_lock.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/kernel_stat.h>
  27. #include <linux/delay.h>
  28. #define __KERNEL_SYSCALLS__
  29. #include <linux/unistd.h>
  30. #include <linux/init.h>
  31. /* #include <linux/openpic.h> */
  32. #include <linux/spinlock.h>
  33. #include <linux/cache.h>
  35. #include <asm/ptrace.h>
  36. #include <asm/atomic.h>
  37. #include <asm/irq.h>
  38. #include <asm/page.h>
  39. #include <asm/pgtable.h>
  40. #include <asm/hardirq.h>
  41. #include <asm/softirq.h>
  42. #include <asm/init.h>
  43. #include <asm/io.h>
  44. #include <asm/prom.h>
  45. #include <asm/smp.h>
  46. #include <asm/naca.h>
  47. #include <asm/paca.h>
  48. #include <asm/iSeries/LparData.h>
  49. #include <asm/iSeries/HvCall.h>
  50. #include <asm/iSeries/HvCallCfg.h>
  51. #include <asm/time.h>
  52. #include <asm/ppcdebug.h>
  53. #include "open_pic.h"
  54. #include <asm/machdep.h>
  55. #if defined(CONFIG_DUMP) || defined(CONFIG_DUMP_MODULE)
  56. int (*dump_ipi_function_ptr)(struct pt_regs *);
  57. #include <linux/dump.h>
  58. #endif
  60. #ifdef CONFIG_KDB
  61. #include <linux/kdb.h>
  62. #endif
  64. int smp_threads_ready = 0;
  65. volatile int smp_commenced = 0;
  66. int smp_num_cpus = 1;
  67. int smp_tb_synchronized = 0;
  68. extern atomic_t ipi_recv;
  69. extern atomic_t ipi_sent;
  70. spinlock_t kernel_flag __cacheline_aligned = SPIN_LOCK_UNLOCKED;
  71. cycles_t cacheflush_time;
  72. static int max_cpus __initdata = NR_CPUS;
  74. unsigned long cpu_online_map;
  76. volatile unsigned long cpu_callin_map[NR_CPUS] = {0,};
  78. #define TB_SYNC_PASSES 4
  79. volatile unsigned long __initdata tb_sync_flag = 0;
  80. volatile unsigned long __initdata tb_offset = 0;
  82. extern unsigned char stab_array[];
  84. int start_secondary(void *);
  85. extern int cpu_idle(void *unused);
  86. void smp_call_function_interrupt(void);
  87. void smp_message_pass(int target, int msg, unsigned long data, int wait);
  88. static unsigned long iSeries_smp_message[NR_CPUS];
  90. void xics_setup_cpu(void);
  91. void xics_cause_IPI(int cpu);
  93. /*
  94.  * XICS only has a single IPI, so encode the messages per CPU
  95.  */
  96. volatile unsigned long xics_ipi_message[NR_CPUS] = {0};
  98. #define smp_message_pass(t,m,d,w) 
  99.     do {     atomic_inc(&ipi_sent); 
  100.      ppc_md.smp_message_pass((t),(m),(d),(w)); 
  101.        } while(0)
  103. #ifdef CONFIG_KDB
  104. /* save regs here before calling kdb_ipi */
  105. struct pt_regs *kdb_smp_regs[NR_CPUS]; 
  107. /* called for each processor.. drop each into kdb. */
  108. void smp_kdb_stop_proc(void)
  109. {
  110.     kdb_ipi(kdb_smp_regs[smp_processor_id()], NULL);
  111. }
  113. void smp_kdb_stop(void)
  114. {
  115.   int ret=0;
  116.   ret =    smp_call_function(smp_kdb_stop_proc, NULL, 1, 0);
  117. }
  119. #endif
  121. static inline void set_tb(unsigned int upper, unsigned int lower)
  122. {
  123. mtspr(SPRN_TBWL, 0);
  124. mtspr(SPRN_TBWU, upper);
  125. mtspr(SPRN_TBWL, lower);
  126. }
  128. void iSeries_smp_message_recv( struct pt_regs * regs )
  129. {
  130. int cpu = smp_processor_id();
  131. int msg;
  133. if ( smp_num_cpus < 2 )
  134. return;
  136. for ( msg = 0; msg < 4; ++msg )
  137. if ( test_and_clear_bit( msg, &iSeries_smp_message[cpu] ) )
  138. smp_message_recv( msg, regs );
  140. }
  142. static void smp_iSeries_message_pass(int target, int msg, unsigned long data, int wait)
  143. {
  144. int i;
  145. for (i = 0; i < smp_num_cpus; ++i) {
  146. if ( (target == MSG_ALL) || 
  147.                     (target == i) || 
  148.                     ((target == MSG_ALL_BUT_SELF) && (i != smp_processor_id())) ) {
  149. set_bit( msg, &iSeries_smp_message[i] );
  150. HvCall_sendIPI(&(paca[i]));
  151. }
  152. }
  153. }
  155. static int smp_iSeries_numProcs(void)
  156. {
  157. unsigned np, i;
  158. struct ItLpPaca * lpPaca;
  160. np = 0;
  161.         for (i=0; i < MAX_PACAS; ++i) {
  162.                 lpPaca = paca[i].xLpPacaPtr;
  163.                 if ( lpPaca->xDynProcStatus < 2 ) {
  164.                         ++np;
  165.                 }
  166.         }
  167. return np;
  168. }
  170. static int smp_iSeries_probe(void)
  171. {
  172. unsigned i;
  173. unsigned np;
  174. struct ItLpPaca * lpPaca;
  176. np = 0;
  177. for (i=0; i < MAX_PACAS; ++i) {
  178. lpPaca = paca[i].xLpPacaPtr;
  179. if ( lpPaca->xDynProcStatus < 2 ) {
  180. ++np;
  181. paca[i].next_jiffy_update_tb = paca[0].next_jiffy_update_tb;
  182. }
  183. }
  185. smp_tb_synchronized = 1;
  186. return np;
  187. }
  189. static void smp_iSeries_kick_cpu(int nr)
  190. {
  191. struct ItLpPaca * lpPaca;
  192. /* Verify we have a Paca for processor nr */
  193. if ( ( nr <= 0 ) ||
  194.      ( nr >= MAX_PACAS ) )
  195. return;
  196. /* Verify that our partition has a processor nr */
  197. lpPaca = paca[nr].xLpPacaPtr;
  198. if ( lpPaca->xDynProcStatus >= 2 )
  199. return;
  201. /* The information for processor bringup must
  202.  * be written out to main store before we release
  203.  * the processor.
  204.  */
  205. mb();
  207. /* The processor is currently spinning, waiting
  208.  * for the xProcStart field to become non-zero
  209.  * After we set xProcStart, the processor will
  210.  * continue on to secondary_start in iSeries_head.S
  211.  */
  212. paca[nr].xProcStart = 1;
  213. }
  215. static void smp_iSeries_setup_cpu(int nr)
  216. {
  217. }
  219. /* This is called very early. */
  220. void smp_init_iSeries(void)
  221. {
  222. ppc_md.smp_message_pass = smp_iSeries_message_pass;
  223. ppc_md.smp_probe        = smp_iSeries_probe;
  224. ppc_md.smp_kick_cpu     = smp_iSeries_kick_cpu;
  225. ppc_md.smp_setup_cpu    = smp_iSeries_setup_cpu;
  227. naca->processorCount = smp_iSeries_numProcs();
  228. }
  231. static void
  232. smp_openpic_message_pass(int target, int msg, unsigned long data, int wait)
  233. {
  234. /* make sure we're sending something that translates to an IPI */
  235. if ( msg > 0x3 ){
  236. printk("SMP %d: smp_message_pass: unknown msg %dn",
  237.        smp_processor_id(), msg);
  238. return;
  239. }
  240. switch ( target )
  241. {
  242. case MSG_ALL:
  243. openpic_cause_IPI(msg, 0xffffffff);
  244. break;
  245. case MSG_ALL_BUT_SELF:
  246. openpic_cause_IPI(msg,
  247.   0xffffffff & ~(1 << smp_processor_id()));
  248. break;
  249. default:
  250. openpic_cause_IPI(msg, 1<<target);
  251. break;
  252. }
  253. }
  255. static int
  256. smp_chrp_probe(void)
  257. {
  258. if (naca->processorCount > 1)
  259. openpic_request_IPIs();
  261. return naca->processorCount;
  262. }
  264. static void
  265. smp_kick_cpu(int nr)
  266. {
  267. /* Verify we have a Paca for processor nr */
  268. if ( ( nr <= 0 ) ||
  269.      ( nr >= MAX_PACAS ) )
  270. return;
  272. /* The information for processor bringup must
  273.  * be written out to main store before we release
  274.  * the processor.
  275.  */
  276. mb();
  278. /* The processor is currently spinning, waiting
  279.  * for the xProcStart field to become non-zero
  280.  * After we set xProcStart, the processor will
  281.  * continue on to secondary_start in iSeries_head.S
  282.  */
  283. paca[nr].xProcStart = 1;
  284. }
  286. static void smp_space_timers( unsigned nr )
  287. {
  288. unsigned long offset, i;
  290. offset = tb_ticks_per_jiffy / nr;
  291. for ( i=1; i<nr; ++i ) {
  292. paca[i].next_jiffy_update_tb = paca[i-1].next_jiffy_update_tb + offset;
  293. }
  294. }
  296. static void
  297. smp_chrp_setup_cpu(int cpu_nr)
  298. {
  299. static atomic_t ready = ATOMIC_INIT(1);
  300. static volatile int frozen = 0;
  302. if (naca->platform == PLATFORM_PSERIES_LPAR) {
  303. /* timebases already synced under the hypervisor. */
  304. paca[cpu_nr].next_jiffy_update_tb = tb_last_stamp = get_tb();
  305. if (cpu_nr == 0) {
  306. naca->tb_orig_stamp = tb_last_stamp;
  307. /* Should update naca->stamp_xsec.
  308.  * For now we leave it which means the time can be some
  309.  * number of msecs off until someone does a settimeofday()
  310.  */
  311. }
  312. smp_tb_synchronized = 1;
  313. } else {
  314. if (cpu_nr == 0) {
  315. /* wait for all the others */
  316. while (atomic_read(&ready) < smp_num_cpus)
  317. barrier();
  318. atomic_set(&ready, 1);
  319. /* freeze the timebase */
  320. rtas_call(rtas_token("freeze-time-base"), 0, 1, NULL);
  321. mb();
  322. frozen = 1;
  323. set_tb(0, 0);
  324. paca[0].next_jiffy_update_tb = 0;
  325. smp_space_timers(smp_num_cpus);
  326. while (atomic_read(&ready) < smp_num_cpus)
  327. barrier();
  328. /* thaw the timebase again */
  329. rtas_call(rtas_token("thaw-time-base"), 0, 1, NULL);
  330. mb();
  331. frozen = 0;
  332. tb_last_stamp = get_tb();
  333. naca->tb_orig_stamp = tb_last_stamp;
  334. smp_tb_synchronized = 1;
  335. } else {
  336. atomic_inc(&ready);
  337. while (!frozen)
  338. barrier();
  339. set_tb(0, 0);
  340. mb();
  341. atomic_inc(&ready);
  342. while (frozen)
  343. barrier();
  344. }
  345. }
  347. if (OpenPIC_Addr) {
  348. do_openpic_setup_cpu();
  349. } else {
  350.   if (cpu_nr > 0)
  351.     xics_setup_cpu();
  352. }
  353. }
  355. static void
  356. smp_xics_message_pass(int target, int msg, unsigned long data, int wait)
  357. {
  358. int i;
  360. for (i = 0; i < smp_num_cpus; ++i) {
  361. if (target == MSG_ALL || target == i
  362.     || (target == MSG_ALL_BUT_SELF
  363. && i != smp_processor_id())) {
  364. set_bit(msg, &xics_ipi_message[i]);
  365. mb();
  366. xics_cause_IPI(i);
  367. }
  368. }
  369. }
  371. static int
  372. smp_xics_probe(void)
  373. {
  374. return naca->processorCount;
  375. }
  377. /* This is called very early */
  378. void smp_init_pSeries(void)
  379. {
  380. if(naca->interrupt_controller == IC_OPEN_PIC) {
  381. ppc_md.smp_message_pass = smp_openpic_message_pass;
  382. ppc_md.smp_probe        = smp_chrp_probe;
  383. ppc_md.smp_kick_cpu     = smp_kick_cpu;
  384. ppc_md.smp_setup_cpu    = smp_chrp_setup_cpu;
  385. } else {
  386. ppc_md.smp_message_pass = smp_xics_message_pass;
  387. ppc_md.smp_probe        = smp_xics_probe;
  388. ppc_md.smp_kick_cpu     = smp_kick_cpu;
  389. ppc_md.smp_setup_cpu    = smp_chrp_setup_cpu;
  390. }
  391. }
  394. void smp_local_timer_interrupt(struct pt_regs * regs)
  395. {
  396. if (!--(get_paca()->prof_counter)) {
  397. update_process_times(user_mode(regs));
  398. (get_paca()->prof_counter)=get_paca()->prof_multiplier;
  399. }
  400. }
  402. void smp_message_recv(int msg, struct pt_regs *regs)
  403. {
  404. atomic_inc(&ipi_recv);
  406. switch( msg ) {
  407. case PPC_MSG_CALL_FUNCTION:
  408. #ifdef CONFIG_KDB
  409. kdb_smp_regs[smp_processor_id()]=regs;
  410. #endif
  411. smp_call_function_interrupt();
  412. break;
  413. case PPC_MSG_RESCHEDULE: 
  414. current->need_resched = 1;
  415. break;
  416. #ifdef CONFIG_XMON
  417. case PPC_MSG_XMON_BREAK:
  418.         /* ToDo: need a nmi way to handle this.  Soft disable? */
  419. #if defined(CONFIG_DUMP) || defined(CONFIG_DUMP_MODULE)
  420.         if (dump_ipi_function_ptr) {
  421. printk(KERN_ALERT "got dump ipi...n");
  422. dump_ipi_function_ptr(regs);
  423. } else
  424. #endif
  425. xmon(regs);
  426. break;
  427. #endif /* CONFIG_XMON */
  428. default:
  429. printk("SMP %d: smp_message_recv(): unknown msg %dn",
  430.        smp_processor_id(), msg);
  431. break;
  432. }
  433. }
  435. void smp_send_reschedule(int cpu)
  436. {
  437. smp_message_pass(cpu, PPC_MSG_RESCHEDULE, 0, 0);
  438. }
  440. #ifdef CONFIG_XMON
  441. void smp_send_xmon_break(int cpu)
  442. {
  443. smp_message_pass(cpu, PPC_MSG_XMON_BREAK, 0, 0);
  444. }
  445. #endif /* CONFIG_XMON */
  447. #if defined(CONFIG_DUMP) || defined(CONFIG_DUMP_MODULE)
  448. void dump_send_ipi(int (*dump_ipi_callback)(struct pt_regs *))
  449. {
  450. dump_ipi_function_ptr = dump_ipi_callback;
  451. if (dump_ipi_callback) {
  452. printk(KERN_ALERT "dump_send_ipi...n");
  453. mb();
  454. smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_XMON_BREAK, 0, 0);
  455. }
  456. }
  457. #endif
  459. static void stop_this_cpu(void *dummy)
  460. {
  461. __cli();
  462. while (1)
  463. ;
  464. }
  466. void smp_send_stop(void)
  467. {
  468. smp_call_function(stop_this_cpu, NULL, 1, 0);
  469. smp_num_cpus = 1;
  470. }
  472. /*
  473.  * Structure and data for smp_call_function(). This is designed to minimise
  474.  * static memory requirements. It also looks cleaner.
  475.  * Stolen from the i386 version.
  476.  */
  477. static spinlock_t call_lock __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
  479. static struct call_data_struct {
  480. void (*func) (void *info);
  481. void *info;
  482. atomic_t started;
  483. atomic_t finished;
  484. int wait;
  485. } *call_data;
  487. /*
  488.  * This function sends a 'generic call function' IPI to all other CPUs
  489.  * in the system.
  490.  *
  491.  * [SUMMARY] Run a function on all other CPUs.
  492.  * <func> The function to run. This must be fast and non-blocking.
  493.  * <info> An arbitrary pointer to pass to the function.
  494.  * <nonatomic> currently unused.
  495.  * <wait> If true, wait (atomically) until function has completed on other CPUs.
  496.  * [RETURNS] 0 on success, else a negative status code. Does not return until
  497.  * remote CPUs are nearly ready to execute <<func>> or are or have executed.
  498.  *
  499.  * You must not call this function with disabled interrupts or from a
  500.  * hardware interrupt handler or from a bottom half handler.
  501.  */
  502. int smp_call_function (void (*func) (void *info), void *info, int nonatomic,
  503. int wait)
  505. { 
  506. struct call_data_struct data;
  507. int ret = -1, cpus = smp_num_cpus-1;
  508. int timeout;
  510. if (!cpus)
  511. return 0;
  513. data.func = func;
  514. data.info = info;
  515. atomic_set(&data.started, 0);
  516. data.wait = wait;
  517. if (wait)
  518. atomic_set(&data.finished, 0);
  520. spin_lock_bh(&call_lock);
  521. call_data = &data;
  522. /* Send a message to all other CPUs and wait for them to respond */
  523. smp_message_pass(MSG_ALL_BUT_SELF, PPC_MSG_CALL_FUNCTION, 0, 0);
  525. /* Wait for response */
  526. timeout = 8000000;
  527. while (atomic_read(&data.started) != cpus) {
  528. HMT_low();
  529. if (--timeout == 0) {
  530. printk("smp_call_function on cpu %d: other cpus not responding (%d)n",
  531.        smp_processor_id(), atomic_read(&data.started));
  532. #ifdef CONFIG_XMON
  533.                         xmon(0);
  534. #endif
  535. #ifdef CONFIG_KDB
  536. kdb(KDB_REASON_CALL,0, (kdb_eframe_t) 0);
  537. #endif
  539. #ifdef CONFIG_PPC_ISERIES
  540. HvCall_terminateMachineSrc();
  541. #endif
  542. goto out;
  543. }
  544. barrier();
  545. udelay(1);
  546. }
  548. if (wait) {
  549. timeout = 1000000;
  550. while (atomic_read(&data.finished) != cpus) {
  551. HMT_low();
  552. if (--timeout == 0) {
  553. printk("smp_call_function on cpu %d: other cpus not finishing (%d/%d)n",
  554.        smp_processor_id(), atomic_read(&data.finished), atomic_read(&data.started));
  555. #ifdef CONFIG_PPC_ISERIES
  556. HvCall_terminateMachineSrc();
  557. #endif
  558. goto out;
  559. }
  560. barrier();
  561. udelay(1);
  562. }
  563. }
  564. ret = 0;
  566.  out:
  567. HMT_medium();
  568. spin_unlock_bh(&call_lock);
  569. return ret;
  570. }
  572. void smp_call_function_interrupt(void)
  573. {
  574. void (*func) (void *info) = call_data->func;
  575. void *info = call_data->info;
  576. int wait = call_data->wait;
  578. /*
  579.  * Notify initiating CPU that I've grabbed the data and am
  580.  * about to execute the function
  581.  */
  582. atomic_inc(&call_data->started);
  583. /*
  584.  * At this point the info structure may be out of scope unless wait==1
  585.  */
  586. (*func)(info);
  587. if (wait)
  588. atomic_inc(&call_data->finished);
  589. }
  592. extern unsigned long decr_overclock;
  594. void __init smp_boot_cpus(void)
  595. {
  596. extern struct current_set_struct current_set[];
  597. extern void __secondary_start_chrp(void);
  598. int i, cpu_nr;
  599. struct task_struct *p;
  600. unsigned long sp;
  602. printk("Entering SMP Mode...n");
  603. PPCDBG(PPCDBG_SMP, "smp_boot_cpus: start.  NR_CPUS = 0x%lxn", NR_CPUS);
  605. smp_num_cpus = 1;
  606.         smp_store_cpu_info(0);
  607. cpu_online_map = 1UL;
  609. /*
  610.  * assume for now that the first cpu booted is
  611.  * cpu 0, the master -- Cort
  612.  */
  613. cpu_callin_map[0] = 1;
  614. current->processor = 0;
  616. init_idle();
  618. for (i = 0; i < NR_CPUS; i++) {
  619. paca[i].prof_counter = 1;
  620. paca[i].prof_multiplier = 1;
  621. if(i != 0) {
  622.         /*
  623.  * Processor 0's segment table is statically 
  624.  * initialized to real address 0x5000.  The
  625.  * Other processor's tables are created and
  626.  * initialized here.
  627.  */
  628. paca[i].xStab_data.virt = (unsigned long)&stab_array[PAGE_SIZE * (i-1)];
  629. memset((void *)paca[i].xStab_data.virt, 0, PAGE_SIZE); 
  630. paca[i].xStab_data.real = __v2a(paca[i].xStab_data.virt);
  631. paca[i].default_decr = tb_ticks_per_jiffy / decr_overclock;
  632. }
  633. }
  635. /*
  636.  * XXX very rough, assumes 20 bus cycles to read a cache line,
  637.  * timebase increments every 4 bus cycles, 32kB L1 data cache.
  638.  */
  639. cacheflush_time = 5 * 1024;
  641. /* Probe arch for CPUs */
  642. cpu_nr = ppc_md.smp_probe();
  644. printk("Probe found %d CPUsn", cpu_nr);
  646. /*
  647.  * only check for cpus we know exist.  We keep the callin map
  648.  * with cpus at the bottom -- Cort
  649.  */
  650. if (cpu_nr > max_cpus)
  651. cpu_nr = max_cpus;
  653. #ifdef CONFIG_PPC_ISERIES
  654. smp_space_timers( cpu_nr );
  655. #endif
  657. printk("Waiting for %d CPUsn", cpu_nr-1);
  659. for ( i = 1 ; i < cpu_nr; i++ ) {
  660. int c;
  661. struct pt_regs regs;
  663. /* create a process for the processor */
  664. /* we don't care about the values in regs since we'll
  665.    never reschedule the forked task. */
  666. /* We DO care about one bit in the pt_regs we
  667.    pass to do_fork.  That is the MSR_FP bit in
  668.    regs.msr.  If that bit is on, then do_fork
  669.    (via copy_thread) will call giveup_fpu.
  670.    giveup_fpu will get a pointer to our (current's)
  671.    last register savearea via current->thread.regs
  672.    and using that pointer will turn off the MSR_FP,
  673.    MSR_FE0 and MSR_FE1 bits.  At this point, this
  674.    pointer is pointing to some arbitrary point within
  675.    our stack */
  677. memset(&regs, 0, sizeof(struct pt_regs));
  679. if (do_fork(CLONE_VM|CLONE_PID, 0, &regs, 0) < 0)
  680. panic("failed fork for CPU %d", i);
  681. p = init_task.prev_task;
  682. if (!p)
  683. panic("No idle task for CPU %d", i);
  685. PPCDBG(PPCDBG_SMP,"tProcessor %d, task = 0x%lxn", i, p);
  687. del_from_runqueue(p);
  688. unhash_process(p);
  689. init_tasks[i] = p;
  691. p->processor = i;
  692. p->cpus_runnable = 1 << i; /* we schedule the first task manually */
  693. current_set[i].task = p;
  694. sp = ((unsigned long)p) + sizeof(union task_union)
  695. - STACK_FRAME_OVERHEAD;
  696. current_set[i].sp_real = (void *)__v2a(sp);
  698. /* wake up cpus */
  699. ppc_md.smp_kick_cpu(i);
  701. /*
  702.  * wait to see if the cpu made a callin (is actually up).
  703.  * use this value that I found through experimentation.
  704.  * -- Cort
  705.  */
  706. for ( c = 5000; c && !cpu_callin_map[i] ; c-- ) {
  707. udelay(100);
  708. }
  710. if ( cpu_callin_map[i] )
  711. {
  712. printk("Processor %d found.n", i);
  713. PPCDBG(PPCDBG_SMP, "tProcessor %d found.n", i);
  714. /* this sync's the decr's -- Cort */
  715. smp_num_cpus++;
  716. } else {
  717. printk("Processor %d is stuck.n", i);
  718. PPCDBG(PPCDBG_SMP, "tProcessor %d is stuck.n", i);
  719. }
  720. }
  722. /* Setup CPU 0 last (important) */
  723. ppc_md.smp_setup_cpu(0);
  725. if (smp_num_cpus < 2) {
  726.         tb_last_stamp = get_tb();
  727. smp_tb_synchronized = 1;
  728. }
  729. }
  731. void __init smp_commence(void)
  732. {
  733. /*
  734.  * Lets the callin's below out of their loop.
  735.  */
  736. PPCDBG(PPCDBG_SMP, "smp_commence: startn"); 
  737. wmb();
  738. smp_commenced = 1;
  739. }
  741. void __init smp_callin(void)
  742. {
  743. int cpu = current->processor;
  745.         smp_store_cpu_info(cpu);
  746. set_dec(paca[cpu].default_decr);
  747. cpu_callin_map[cpu] = 1;
  749. ppc_md.smp_setup_cpu(cpu);
  751. init_idle();
  753. set_bit(smp_processor_id(), &cpu_online_map);
  755. while(!smp_commenced) {
  756. barrier();
  757. }
  758. __sti();
  759. }
  761. /* intel needs this */
  762. void __init initialize_secondary(void)
  763. {
  764. }
  766. /* Activate a secondary processor. */
  767. int start_secondary(void *unused)
  768. {
  769. int cpu; 
  771. cpu = current->processor;
  772. atomic_inc(&init_mm.mm_count);
  773. current->active_mm = &init_mm;
  774. smp_callin();
  776. /* Go into the idle loop. */
  777. return cpu_idle(NULL);
  778. }
  780. void __init smp_setup(char *str, int *ints)
  781. {
  782. }
  784. int setup_profiling_timer(unsigned int multiplier)
  785. {
  786. return 0;
  787. }
  789. /* this function is called for each processor
  790.  */
  791. void __init smp_store_cpu_info(int id)
  792. {
  793.         paca[id].pvr = _get_PVR();
  794. }
  796. static int __init maxcpus(char *str)
  797. {
  798. get_option(&str, &max_cpus);
  799. return 1;
  800. }
  802. __setup("maxcpus=", maxcpus);