mips: Use generic idle thread allocation

	select HAVE_MEMBLOCK

	select HAVE_MEMBLOCK_NODE_MAP

	select ARCH_DISCARD_MEMBLOCK

	select GENERIC_SMP_IDLE_THREAD

menu "Machine selection"

	cpu_set(0, cpu_callin_map);

}

/*

 * Called once for each "cpu_possible(cpu)".  Needs to spin up the cpu

 * and keep control until "cpu_online(cpu)" is set.  Note: cpu is

 * physical, not logical.

 */

static struct task_struct *cpu_idle_thread[NR_CPUS];

struct create_idle {

	struct work_struct work;

	struct task_struct *idle;

	struct completion done;

	int cpu;

};

static void __cpuinit do_fork_idle(struct work_struct *work)

{

	struct create_idle *c_idle =

		container_of(work, struct create_idle, work);

	c_idle->idle = fork_idle(c_idle->cpu);

	complete(&c_idle->done);

}

int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *tidle)

{

	struct task_struct *idle;

	/*

	 * Processor goes to start_secondary(), sets online flag

	 * The following code is purely to make sure

	 * Linux can schedule processes on this slave.

	 */

	if (!cpu_idle_thread[cpu]) {

		/*

		 * Schedule work item to avoid forking user task

		 * Ported from arch/x86/kernel/smpboot.c

		 */

		struct create_idle c_idle = {

			.cpu    = cpu,

			.done   = COMPLETION_INITIALIZER_ONSTACK(c_idle.done),

		};

		INIT_WORK_ONSTACK(&c_idle.work, do_fork_idle);

		schedule_work(&c_idle.work);

		wait_for_completion(&c_idle.done);

		idle = cpu_idle_thread[cpu] = c_idle.idle;

		if (IS_ERR(idle))

			panic(KERN_ERR "Fork failed for CPU %d", cpu);

	} else {

		idle = cpu_idle_thread[cpu];

		init_idle(idle, cpu);

	}

	mp_ops->boot_secondary(cpu, idle);

	mp_ops->boot_secondary(cpu, tidle);

	/*

	 * Trust is futile.  We should really have timeouts ...