The calibration is executed as part of the startup sequence, prior to kernel initialization. The code snippet below 
shows the implementation. That is part of QNX 8.0 BSP.

/**
 * Calibrate the frequency of TSC in Hz, using the default timer
 * @return	TSC cycles per second (Hz)
 */
uint64_t calibrate_tsc(unsigned long ns)
{
	unsigned long ticks;
	unsigned start_tick;
	uint64_t init_diff;
	uint64_t tick_diff;
	uint64_t start_tsc;
	uint64_t end_tsc;
	uint64_t elapsed_time_nano;
	uint64_t cycles_per_sec;
	unsigned factor;
	unsigned scale_factor;

	ticks = timer_ns2tick(ns);
	start_tick = timer_start();

	/* preparation: wait for the beginning of a tick to sync with rdtsc */
	do {
		init_diff = timer_diff(start_tick);
	} while (init_diff == 0);
	ticks += init_diff;

	/* actual benchmark */
	rdtsc_ordered(&start_tsc);
	__asm__ __volatile__ (".align 16");
	do {
		tick_diff = timer_diff(start_tick);
	} while (tick_diff < ticks);

	rdtsc_ordered(&end_tsc);

	/* calculation based on end_tsc, start_tsc and tick_diff */
	tick_diff -= init_diff;	/* init_diff is measured prior to the beginning of benchmark */

	/* Please, refer to [A Note About Using qtime::timer_rate And qtime::timer_scale]
	 * in services/system/doc/clock.txt and services/system/ker/nano_clock.c:clock_start()
	 * and jiffy_to_ns() for the detail
	 */
    if (lsp.qtime.p->timer_scale < NANO_SCALE) {
        factor = (unsigned)(NANO_SCALE - lsp.qtime.p->timer_scale);
    } else {
        factor = (unsigned)(lsp.qtime.p->timer_scale - NANO_SCALE);
    }

    scale_factor = 1;
    while (factor != 0) {
        scale_factor *= 10;
        --factor;
    }

	if (lsp.qtime.p->timer_scale < NANO_SCALE) {	/* e.g. if nano_conversion_scale is -6, it means 'timer_scale' is femto */

		elapsed_time_nano = ((tick_diff * (lsp.qtime.p->timer_period)) + (scale_factor >> 1)) / scale_factor;	/* to 
nanoseconds */
	} else {	/* e.g if nano_conversion_scale is 3, it means 'timer_scale' is micro */
		elapsed_time_nano = (tick_diff * (lsp.qtime.p->timer_period)) * scale_factor;	/* to nanoseconds */
	}

	cycles_per_sec = ((end_tsc - start_tsc) * 1000000000) / elapsed_time_nano;
	return cycles_per_sec;
}