1/*
2 * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/*
29 *	File:	i386/cpu.c
30 *
31 *	cpu specific routines
32 */
33
34#include <kern/kalloc.h>
35#include <kern/misc_protos.h>
36#include <kern/machine.h>
37#include <mach/processor_info.h>
38#include <i386/pmap.h>
39#include <i386/machine_cpu.h>
40#include <i386/machine_routines.h>
41#include <i386/misc_protos.h>
42#include <i386/cpu_threads.h>
43#include <i386/rtclock_protos.h>
44#include <i386/cpuid.h>
45#if CONFIG_VMX
46#include <i386/vmx/vmx_cpu.h>
47#endif
48#include <vm/vm_kern.h>
49#include <kern/timer_call.h>
50
51struct processor	processor_master;
52
53/*ARGSUSED*/
54kern_return_t
55cpu_control(
56	int			slot_num,
57	processor_info_t	info,
58	unsigned int		count)
59{
60	printf("cpu_control(%d,%p,%d) not implemented\n",
61		slot_num, info, count);
62	return (KERN_FAILURE);
63}
64
65/*ARGSUSED*/
66kern_return_t
67cpu_info_count(
68        __unused processor_flavor_t      flavor,
69	unsigned int			*count)
70{
71	*count = 0;
72	return (KERN_FAILURE);
73}
74
75/*ARGSUSED*/
76kern_return_t
77cpu_info(
78        processor_flavor_t      flavor,
79	int			slot_num,
80	processor_info_t	info,
81	unsigned int		*count)
82{
83	printf("cpu_info(%d,%d,%p,%p) not implemented\n",
84		flavor, slot_num, info, count);
85	return (KERN_FAILURE);
86}
87
88void
89cpu_sleep(void)
90{
91	cpu_data_t	*cdp = current_cpu_datap();
92
93	PE_cpu_machine_quiesce(cdp->cpu_id);
94
95	cpu_thread_halt();
96}
97
98void
99cpu_init(void)
100{
101	cpu_data_t	*cdp = current_cpu_datap();
102
103	timer_call_queue_init(&cdp->rtclock_timer.queue);
104	cdp->rtclock_timer.deadline = EndOfAllTime;
105
106	cdp->cpu_type = cpuid_cputype();
107	cdp->cpu_subtype = cpuid_cpusubtype();
108
109	i386_activate_cpu();
110}
111
112kern_return_t
113cpu_start(
114	int cpu)
115{
116	kern_return_t		ret;
117
118	if (cpu == cpu_number()) {
119		cpu_machine_init();
120		return KERN_SUCCESS;
121	}
122
123	/*
124	 * Try to bring the CPU back online without a reset.
125	 * If the fast restart doesn't succeed, fall back to
126	 * the slow way.
127	 */
128	ret = intel_startCPU_fast(cpu);
129	if (ret != KERN_SUCCESS) {
130		/*
131		 * Should call out through PE.
132		 * But take the shortcut here.
133		 */
134		ret = intel_startCPU(cpu);
135	}
136
137	if (ret != KERN_SUCCESS)
138		kprintf("cpu: cpu_start(%d) returning failure!\n", cpu);
139
140	return(ret);
141}
142
143void
144cpu_exit_wait(
145	int cpu)
146{
147    	cpu_data_t	*cdp = cpu_datap(cpu);
148	boolean_t	intrs_enabled;
149	uint64_t	tsc_timeout;
150
151	/*
152	 * Wait until the CPU indicates that it has stopped.
153	 * Disable interrupts while the topo lock is held -- arguably
154	 * this should always be done but in this instance it can lead to
155	 * a timeout if long-running interrupt were to occur here.
156	 */
157	intrs_enabled = ml_set_interrupts_enabled(FALSE);
158	simple_lock(&x86_topo_lock);
159	/* Set a generous timeout of several seconds (in TSC ticks) */
160	tsc_timeout = rdtsc64() + (10ULL * 1000 * 1000 * 1000);
161	while ((cdp->lcpu.state != LCPU_HALT)
162	       && (cdp->lcpu.state != LCPU_OFF)
163	       && !cdp->lcpu.stopped) {
164	    simple_unlock(&x86_topo_lock);
165	    ml_set_interrupts_enabled(intrs_enabled);
166	    cpu_pause();
167	    if (rdtsc64() > tsc_timeout)
168		panic("cpu_exit_wait(%d) timeout", cpu);
169	    ml_set_interrupts_enabled(FALSE);
170	    simple_lock(&x86_topo_lock);
171	}
172	simple_unlock(&x86_topo_lock);
173	ml_set_interrupts_enabled(intrs_enabled);
174}
175
176void
177cpu_machine_init(
178	void)
179{
180	cpu_data_t	*cdp = current_cpu_datap();
181
182	PE_cpu_machine_init(cdp->cpu_id, !cdp->cpu_boot_complete);
183	cdp->cpu_boot_complete = TRUE;
184	cdp->cpu_running = TRUE;
185	ml_init_interrupt();
186
187#if CONFIG_VMX
188	/* initialize VMX for every CPU */
189	vmx_cpu_init();
190#endif
191}
192
193processor_t
194cpu_processor_alloc(boolean_t is_boot_cpu)
195{
196	int		ret;
197	processor_t	proc;
198
199	if (is_boot_cpu)
200		return &processor_master;
201
202	ret = kmem_alloc(kernel_map, (vm_offset_t *) &proc, sizeof(*proc));
203	if (ret != KERN_SUCCESS)
204		return NULL;
205
206	bzero((void *) proc, sizeof(*proc));
207	return proc;
208}
209
210void
211cpu_processor_free(processor_t proc)
212{
213	if (proc != NULL && proc != &processor_master)
214		kfree((void *) proc, sizeof(*proc));
215}
216
217processor_t
218current_processor(void)
219{
220	return current_cpu_datap()->cpu_processor;
221}
222
223processor_t
224cpu_to_processor(
225	int			cpu)
226{
227	return cpu_datap(cpu)->cpu_processor;
228}
229
230ast_t *
231ast_pending(void)
232{
233	return (&current_cpu_datap()->cpu_pending_ast);
234}
235
236cpu_type_t
237slot_type(
238	int		slot_num)
239{
240	return (cpu_datap(slot_num)->cpu_type);
241}
242
243cpu_subtype_t
244slot_subtype(
245	int		slot_num)
246{
247	return (cpu_datap(slot_num)->cpu_subtype);
248}
249
250cpu_threadtype_t
251slot_threadtype(
252	int		slot_num)
253{
254	return (cpu_datap(slot_num)->cpu_threadtype);
255}
256
257cpu_type_t
258cpu_type(void)
259{
260	return (current_cpu_datap()->cpu_type);
261}
262
263cpu_subtype_t
264cpu_subtype(void)
265{
266	return (current_cpu_datap()->cpu_subtype);
267}
268
269cpu_threadtype_t
270cpu_threadtype(void)
271{
272	return (current_cpu_datap()->cpu_threadtype);
273}
274