[apple/xnu.git] / osfmk / i386 / tsc.c

/*
 * Copyright (c) 2005-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */

/*
 *	File:		i386/tsc.c
 *	Purpose:	Initializes the TSC and the various conversion
 *			factors needed by other parts of the system.
 */

#include <platforms.h>
#include <mach_kdb.h>

#include <mach/mach_types.h>

#include <kern/cpu_data.h>
#include <kern/cpu_number.h>
#include <kern/clock.h>
#include <kern/host_notify.h>
#include <kern/macro_help.h>
#include <kern/misc_protos.h>
#include <kern/spl.h>
#include <kern/assert.h>
#include <mach/vm_prot.h>
#include <vm/pmap.h>
#include <vm/vm_kern.h>		/* for kernel_map */
#include <i386/ipl.h>
#include <i386/pit.h>
#include <architecture/i386/pio.h>
#include <i386/misc_protos.h>
#include <i386/proc_reg.h>
#include <i386/machine_cpu.h>
#include <i386/mp.h>
#include <i386/cpuid.h>
#include <i386/cpu_data.h>
#include <i386/cpu_threads.h>
#include <i386/perfmon.h>
#include <i386/machine_routines.h>
#include <pexpert/pexpert.h>
#include <machine/limits.h>
#include <machine/commpage.h>
#include <sys/kdebug.h>
#include <pexpert/device_tree.h>
#include <i386/tsc.h>

uint64_t	busFCvtt2n = 0;
uint64_t	busFCvtn2t = 0;
uint64_t	tscFreq = 0;
uint64_t	tscFCvtt2n = 0;
uint64_t	tscFCvtn2t = 0;
uint64_t	tscGranularity = 0;
uint64_t	bus2tsc = 0;

/* Decimal powers: */
#define kilo (1000ULL)
#define Mega (kilo * kilo)
#define Giga (kilo * Mega)
#define Tera (kilo * Giga)
#define Peta (kilo * Tera)

static const char	FSB_Frequency_prop[] = "FSBFrequency";
/*
 * This routine extracts the front-side bus frequency in Hz from
 * the device tree.
 */
static uint64_t
EFI_FSB_frequency(void)
{
	uint64_t	frequency = 0;
	DTEntry		entry;
	void		*value;
	int		size;

	if (DTLookupEntry(0, "/efi/platform", &entry) != kSuccess) {
		kprintf("EFI_FSB_frequency: didn't find /efi/platform\n");
		return 0;
	}
	if (DTGetProperty(entry,FSB_Frequency_prop,&value,&size) != kSuccess) {
		kprintf("EFI_FSB_frequency: property %s not found\n");
		return 0;
	}
	if (size == sizeof(uint64_t)) {
		frequency = *(uint64_t *) value;
		kprintf("EFI_FSB_frequency: read %s value: %llu\n",
			FSB_Frequency_prop, frequency);
		if (!(90*Mega < frequency && frequency < 10*Giga)) {
			kprintf("EFI_FSB_frequency: value out of range\n");
			frequency = 0;
		}
	} else {
		kprintf("EFI_FSB_frequency: unexpected size %d\n", size);
	}
	return frequency;
}

/*
 * Initialize the various conversion factors needed by code referencing
 * the TSC.
 */
void
tsc_init(void)
{
    uint64_t	busFreq;
    uint64_t	busFCvtInt;
    uint32_t	cpuModel;
    uint32_t	cpuFamily;
    uint32_t	xcpuid[4];

    /*
     * Get the FSB frequency and conversion factors.
     */
    busFreq = EFI_FSB_frequency();
    if (busFreq != 0) {
	busFCvtt2n = ((1 * Giga) << 32) / busFreq;
	busFCvtn2t = 0xFFFFFFFFFFFFFFFFULL / busFCvtt2n;
	busFCvtInt = tmrCvt(1 * Peta, 0xFFFFFFFFFFFFFFFFULL / busFreq); 
    } else {
	panic("rtclock_init: EFI not supported!\n");
    }
	
    kprintf(" BUS: Frequency = %6d.%04dMHz, "
	    "cvtt2n = %08X.%08X, cvtn2t = %08X.%08X, "
	    "cvtInt = %08X.%08X\n",
	    (uint32_t)(busFreq / Mega),
	    (uint32_t)(busFreq % Mega), 
	    (uint32_t)(busFCvtt2n >> 32), (uint32_t)busFCvtt2n,
	    (uint32_t)(busFCvtn2t >> 32), (uint32_t)busFCvtn2t,
	    (uint32_t)(busFCvtInt >> 32), (uint32_t)busFCvtInt);

    do_cpuid(1, xcpuid);
    cpuFamily = ( xcpuid[eax] >> 8 ) & 0xf;
    /*
     * Get the extended family if necessary.
     */
    if (cpuFamily == 0x0f)
	cpuFamily += (xcpuid[eax] >> 20) & 0x00ff;

    cpuModel = ( xcpuid[eax] >> 4 ) & 0xf;
    /*
     * Get the extended model if necessary.
     */
    if (cpuFamily == CPUID_FAMILY_686
	|| cpuFamily == CPUID_FAMILY_EXTENDED)
	cpuModel += ((xcpuid[eax] >> 16) & 0xf) << 4;

    /*
     * Get the TSC increment.  The TSC is incremented by this
     * on every bus tick.  Calculate the TSC conversion factors
     * to and from nano-seconds.
     */
    if (cpuFamily == CPUID_FAMILY_686) {
	if (cpuModel == CPUID_MODEL_CORE || cpuModel == CPUID_MODEL_CORE2) {
	uint64_t	prfsts;
	
	prfsts = rdmsr64(IA32_PERF_STS);
	tscGranularity = (uint32_t)(prfsts >> BusRatioShift) & BusRatioMask;
	} else {
	    panic("rtclock_init: unknown CPU model: 0x%X\n",
	      cpuModel);
	}
    } else {
	panic("rtclock_init: unknown CPU family: 0x%X\n",
	      cpuFamily);
    }
	
    tscFCvtt2n = busFCvtt2n / (uint64_t)tscGranularity;
    tscFreq = ((1 * Giga)  << 32) / tscFCvtt2n;
    tscFCvtn2t = 0xFFFFFFFFFFFFFFFFULL / tscFCvtt2n;

    kprintf(" TSC: Frequency = %6d.%04dMHz, "
	    "cvtt2n = %08X.%08X, cvtn2t = %08X.%08X, gran = %d\n",
	    (uint32_t)(tscFreq / Mega),
	    (uint32_t)(tscFreq % Mega), 
	    (uint32_t)(tscFCvtt2n >> 32), (uint32_t)tscFCvtt2n,
	    (uint32_t)(tscFCvtn2t >> 32), (uint32_t)tscFCvtn2t,
	    tscGranularity);

    /*
     * Calculate conversion from BUS to TSC
     */
    bus2tsc = tmrCvt(busFCvtt2n, tscFCvtn2t);
}

void
tsc_get_info(tscInfo_t *info)
{
    info->busFCvtt2n     = busFCvtt2n;
    info->busFCvtn2t     = busFCvtn2t;
    info->tscFreq        = tscFreq;
    info->tscFCvtt2n     = tscFCvtt2n;
    info->tscFCvtn2t     = tscFCvtn2t;
    info->tscGranularity = tscGranularity;
    info->bus2tsc        = bus2tsc;
}
Commit	Line	Data
89b3af67 A	1	/*
	2	* Copyright (c) 2005-2006 Apple Computer, 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	* @OSF_COPYRIGHT@
	30	*/
	31
	32	/*
	33	* File: i386/tsc.c
	34	* Purpose: Initializes the TSC and the various conversion
	35	* factors needed by other parts of the system.
	36	*/
	37
	38	#include <platforms.h>
	39	#include <mach_kdb.h>
	40
	41	#include <mach/mach_types.h>
	42
	43	#include <kern/cpu_data.h>
	44	#include <kern/cpu_number.h>
	45	#include <kern/clock.h>
	46	#include <kern/host_notify.h>
	47	#include <kern/macro_help.h>
	48	#include <kern/misc_protos.h>
	49	#include <kern/spl.h>
	50	#include <kern/assert.h>
	51	#include <mach/vm_prot.h>
	52	#include <vm/pmap.h>
	53	#include <vm/vm_kern.h> /* for kernel_map */
	54	#include <i386/ipl.h>
	55	#include <i386/pit.h>
	56	#include <architecture/i386/pio.h>
	57	#include <i386/misc_protos.h>
	58	#include <i386/proc_reg.h>
	59	#include <i386/machine_cpu.h>
	60	#include <i386/mp.h>
	61	#include <i386/cpuid.h>
	62	#include <i386/cpu_data.h>
	63	#include <i386/cpu_threads.h>
	64	#include <i386/perfmon.h>
65	#include <i386/machine_routines.h>
66	#include <pexpert/pexpert.h>
67	#include <machine/limits.h>
68	#include <machine/commpage.h>
69	#include <sys/kdebug.h>
70	#include <pexpert/device_tree.h>
71	#include <i386/tsc.h>
72
73	uint64_t busFCvtt2n = 0;
74	uint64_t busFCvtn2t = 0;
75	uint64_t tscFreq = 0;
76	uint64_t tscFCvtt2n = 0;
77	uint64_t tscFCvtn2t = 0;
78	uint64_t tscGranularity = 0;
79	uint64_t bus2tsc = 0;
80
81	/* Decimal powers: */
82	#define kilo (1000ULL)
83	#define Mega (kilo * kilo)
84	#define Giga (kilo * Mega)
85	#define Tera (kilo * Giga)
86	#define Peta (kilo * Tera)
87
88	static const char FSB_Frequency_prop[] = "FSBFrequency";
89	/*
90	* This routine extracts the front-side bus frequency in Hz from
91	* the device tree.
92	*/
93	static uint64_t
94	EFI_FSB_frequency(void)
95	{
96	uint64_t frequency = 0;
97	DTEntry entry;
98	void *value;
99	int size;
100
101	if (DTLookupEntry(0, "/efi/platform", &entry) != kSuccess) {
102	kprintf("EFI_FSB_frequency: didn't find /efi/platform\n");
103	return 0;
104	}
105	if (DTGetProperty(entry,FSB_Frequency_prop,&value,&size) != kSuccess) {
106	kprintf("EFI_FSB_frequency: property %s not found\n");
107	return 0;
108	}
109	if (size == sizeof(uint64_t)) {
110	frequency = (uint64_t ) value;
111	kprintf("EFI_FSB_frequency: read %s value: %llu\n",
112	FSB_Frequency_prop, frequency);
113	if (!(90Mega < frequency && frequency < 10Giga)) {
114	kprintf("EFI_FSB_frequency: value out of range\n");
115	frequency = 0;
116	}
117	} else {
118	kprintf("EFI_FSB_frequency: unexpected size %d\n", size);
119	}
120	return frequency;
121	}
122
123	/*
124	* Initialize the various conversion factors needed by code referencing
125	* the TSC.
126	*/
127	void
128	tsc_init(void)
129	{
130	uint64_t busFreq;
131	uint64_t busFCvtInt;
132	uint32_t cpuModel;
133	uint32_t cpuFamily;
134	uint32_t xcpuid[4];
135
136	/*
137	* Get the FSB frequency and conversion factors.
138	*/
139	busFreq = EFI_FSB_frequency();
140	if (busFreq != 0) {
141	busFCvtt2n = ((1 * Giga) << 32) / busFreq;
142	busFCvtn2t = 0xFFFFFFFFFFFFFFFFULL / busFCvtt2n;
143	busFCvtInt = tmrCvt(1 * Peta, 0xFFFFFFFFFFFFFFFFULL / busFreq);
144	} else {
145	panic("rtclock_init: EFI not supported!\n");
146	}
147
148	kprintf(" BUS: Frequency = %6d.%04dMHz, "
149	"cvtt2n = %08X.%08X, cvtn2t = %08X.%08X, "
150	"cvtInt = %08X.%08X\n",
151	(uint32_t)(busFreq / Mega),
152	(uint32_t)(busFreq % Mega),
153	(uint32_t)(busFCvtt2n >> 32), (uint32_t)busFCvtt2n,
154	(uint32_t)(busFCvtn2t >> 32), (uint32_t)busFCvtn2t,
155	(uint32_t)(busFCvtInt >> 32), (uint32_t)busFCvtInt);
156
157	do_cpuid(1, xcpuid);
158	cpuFamily = ( xcpuid[eax] >> 8 ) & 0xf;
159	/*
160	* Get the extended family if necessary.
161	*/
162	if (cpuFamily == 0x0f)
163	cpuFamily += (xcpuid[eax] >> 20) & 0x00ff;
164
165	cpuModel = ( xcpuid[eax] >> 4 ) & 0xf;
166	/*
167	* Get the extended model if necessary.
168	*/
169	if (cpuFamily == CPUID_FAMILY_686
170	\|\| cpuFamily == CPUID_FAMILY_EXTENDED)
171	cpuModel += ((xcpuid[eax] >> 16) & 0xf) << 4;
172
173	/*
174	* Get the TSC increment. The TSC is incremented by this
175	* on every bus tick. Calculate the TSC conversion factors
176	* to and from nano-seconds.
177	*/
178	if (cpuFamily == CPUID_FAMILY_686) {
179	if (cpuModel == CPUID_MODEL_CORE \|\| cpuModel == CPUID_MODEL_CORE2) {
180	uint64_t prfsts;
181
182	prfsts = rdmsr64(IA32_PERF_STS);
183	tscGranularity = (uint32_t)(prfsts >> BusRatioShift) & BusRatioMask;
184	} else {
185	panic("rtclock_init: unknown CPU model: 0x%X\n",
186	cpuModel);
187	}
188	} else {
189	panic("rtclock_init: unknown CPU family: 0x%X\n",
190	cpuFamily);
191	}
192
193	tscFCvtt2n = busFCvtt2n / (uint64_t)tscGranularity;
194	tscFreq = ((1 * Giga) << 32) / tscFCvtt2n;
195	tscFCvtn2t = 0xFFFFFFFFFFFFFFFFULL / tscFCvtt2n;
196
197	kprintf(" TSC: Frequency = %6d.%04dMHz, "
198	"cvtt2n = %08X.%08X, cvtn2t = %08X.%08X, gran = %d\n",
199	(uint32_t)(tscFreq / Mega),
200	(uint32_t)(tscFreq % Mega),
201	(uint32_t)(tscFCvtt2n >> 32), (uint32_t)tscFCvtt2n,
202	(uint32_t)(tscFCvtn2t >> 32), (uint32_t)tscFCvtn2t,
203	tscGranularity);
204
205	/*
206	* Calculate conversion from BUS to TSC
207	*/
208	bus2tsc = tmrCvt(busFCvtt2n, tscFCvtn2t);
209	}
210
211	void
212	tsc_get_info(tscInfo_t *info)
213	{
214	info->busFCvtt2n = busFCvtt2n;
215	info->busFCvtn2t = busFCvtn2t;
216	info->tscFreq = tscFreq;
217	info->tscFCvtt2n = tscFCvtt2n;
218	info->tscFCvtn2t = tscFCvtn2t;
219	info->tscGranularity = tscGranularity;
220	info->bus2tsc = bus2tsc;
221	}