+4 -4

drivers/clocksource/clksrc-dbx500-prcmu.c

reviewed

··· 18 18 19 19 #define RATE_32K 32768 20 20 21 21 - #define TIMER_MODE_CONTINOUS 0x1 21 21 + #define TIMER_MODE_CONTINUOUS 0x1 22 22 #define TIMER_DOWNCOUNT_VAL 0xffffffff 23 23 24 24 #define PRCMU_TIMER_REF 0 ··· 55 55 56 56 /* 57 57 * The A9 sub system expects the timer to be configured as 58 58 - * a continous looping timer. 58 58 + * a continuous looping timer. 59 59 * The PRCMU should configure it but if it for some reason 60 60 * don't we do it here. 61 61 */ 62 62 if (readl(clksrc_dbx500_timer_base + PRCMU_TIMER_MODE) != 63 63 - TIMER_MODE_CONTINOUS) { 64 64 - writel(TIMER_MODE_CONTINOUS, 63 63 + TIMER_MODE_CONTINUOUS) { 64 64 + writel(TIMER_MODE_CONTINUOUS, 65 65 clksrc_dbx500_timer_base + PRCMU_TIMER_MODE); 66 66 writel(TIMER_DOWNCOUNT_VAL, 67 67 clksrc_dbx500_timer_base + PRCMU_TIMER_REF);

+1 -1

drivers/clocksource/dw_apb_timer_of.c

reviewed

··· 38 38 } 39 39 40 40 /* 41 41 - * Not all implementations use a periphal clock, so don't panic 41 41 + * Not all implementations use a peripheral clock, so don't panic 42 42 * if it's not present 43 43 */ 44 44 pclk = of_clk_get_by_name(np, "pclk");

+1 -1

drivers/clocksource/hyperv_timer.c

reviewed

··· 457 457 { 458 458 /* 459 459 * Try to set up the TSC page clocksource. If it succeeds, we're 460 460 - * done. Otherwise, set up the MSR clocksoruce. At least one of 460 460 + * done. Otherwise, set up the MSR clocksource. At least one of 461 461 * these will always be available except on very old versions of 462 462 * Hyper-V on x86. In that case we won't have a Hyper-V 463 463 * clocksource, but Linux will still run with a clocksource based

+2 -2

drivers/clocksource/timer-atmel-tcb.c

reviewed

··· 455 455 tcaddr = tc.regs; 456 456 457 457 if (bits == 32) { 458 458 - /* use apropriate function to read 32 bit counter */ 458 458 + /* use appropriate function to read 32 bit counter */ 459 459 clksrc.read = tc_get_cycles32; 460 460 - /* setup ony channel 0 */ 460 460 + /* setup only channel 0 */ 461 461 tcb_setup_single_chan(&tc, best_divisor_idx); 462 462 tc_sched_clock = tc_sched_clock_read32; 463 463 tc_delay_timer.read_current_timer = tc_delay_timer_read32;

+1 -1

drivers/clocksource/timer-fsl-ftm.c

reviewed

··· 116 116 * to the MOD register latches the value into a buffer. The MOD 117 117 * register is updated with the value of its write buffer with 118 118 * the following scenario: 119 119 - * a, the counter source clock is diabled. 119 119 + * a, the counter source clock is disabled. 120 120 */ 121 121 ftm_counter_disable(priv->clkevt_base); 122 122

+1 -1

drivers/clocksource/timer-microchip-pit64b.c

reviewed

··· 237 237 break; 238 238 } 239 239 240 240 - /* Use the bigest prescaler if we didn't match one. */ 240 240 + /* Use the biggest prescaler if we didn't match one. */ 241 241 if (*pres == MCHP_PIT64B_PRES_MAX) 242 242 *pres = MCHP_PIT64B_PRES_MAX - 1; 243 243 }

+2 -2

drivers/clocksource/timer-of.c

reviewed

··· 211 211 } 212 212 213 213 /** 214 214 - * timer_of_cleanup - release timer_of ressources 214 214 + * timer_of_cleanup - release timer_of resources 215 215 * @to: timer_of structure 216 216 * 217 217 - * Release the ressources that has been used in timer_of_init(). 217 217 + * Release the resources that has been used in timer_of_init(). 218 218 * This function should be called in init error cases 219 219 */ 220 220 void __init timer_of_cleanup(struct timer_of *to)

+1 -1

drivers/clocksource/timer-ti-dm-systimer.c

reviewed

··· 589 589 "always-on " : "", t->rate, np->parent); 590 590 591 591 clockevents_config_and_register(dev, t->rate, 592 592 - 3, /* Timer internal resynch latency */ 592 592 + 3, /* Timer internal resync latency */ 593 593 0xffffffff); 594 594 595 595 if (of_machine_is_compatible("ti,am33xx") ||

+1 -1

drivers/clocksource/timer-vf-pit.c

reviewed

··· 136 136 /* 137 137 * The value for the LDVAL register trigger is calculated as: 138 138 * LDVAL trigger = (period / clock period) - 1 139 139 - * The pit is a 32-bit down count timer, when the conter value 139 139 + * The pit is a 32-bit down count timer, when the counter value 140 140 * reaches 0, it will generate an interrupt, thus the minimal 141 141 * LDVAL trigger value is 1. And then the min_delta is 142 142 * minimal LDVAL trigger value + 1, and the max_delta is full 32-bit.

+1 -1

include/linux/clocksource.h

reviewed

··· 70 70 * @mark_unstable: Optional function to inform the clocksource driver that 71 71 * the watchdog marked the clocksource unstable 72 72 * @tick_stable: Optional function called periodically from the watchdog 73 73 - * code to provide stable syncrhonization points 73 73 + * code to provide stable synchronization points 74 74 * @wd_list: List head to enqueue into the watchdog list (internal) 75 75 * @cs_last: Last clocksource value for clocksource watchdog 76 76 * @wd_last: Last watchdog value corresponding to @cs_last

+1 -1

include/linux/timex.h

reviewed

··· 133 133 134 134 /* 135 135 * kernel variables 136 136 - * Note: maximum error = NTP synch distance = dispersion + delay / 2; 136 136 + * Note: maximum error = NTP sync distance = dispersion + delay / 2; 137 137 * estimated error = NTP dispersion. 138 138 */ 139 139 extern unsigned long tick_usec; /* USER_HZ period (usec) */

+3 -3

kernel/time/alarmtimer.c

reviewed

··· 2 2 /* 3 3 * Alarmtimer interface 4 4 * 5 5 - * This interface provides a timer which is similarto hrtimers, 5 5 + * This interface provides a timer which is similar to hrtimers, 6 6 * but triggers a RTC alarm if the box is suspend. 7 7 * 8 8 * This interface is influenced by the Android RTC Alarm timer 9 9 * interface. 10 10 * 11 11 - * Copyright (C) 2010 IBM Corperation 11 11 + * Copyright (C) 2010 IBM Corporation 12 12 * 13 13 * Author: John Stultz <john.stultz@linaro.org> 14 14 */ ··· 811 811 /** 812 812 * alarm_timer_nsleep - alarmtimer nanosleep 813 813 * @which_clock: clockid 814 814 - * @flags: determins abstime or relative 814 814 + * @flags: determines abstime or relative 815 815 * @tsreq: requested sleep time (abs or rel) 816 816 * 817 817 * Handles clock_nanosleep calls against _ALARM clockids

+2 -2

kernel/time/clocksource.c

reviewed

··· 38 38 * calculated mult and shift factors. This guarantees that no 64bit 39 39 * overflow happens when the input value of the conversion is 40 40 * multiplied with the calculated mult factor. Larger ranges may 41 41 - * reduce the conversion accuracy by chosing smaller mult and shift 41 41 + * reduce the conversion accuracy by choosing smaller mult and shift 42 42 * factors. 43 43 */ 44 44 void ··· 518 518 * the suspend time when resuming system. 519 519 * 520 520 * This function is called late in the suspend process from timekeeping_suspend(), 521 521 - * that means processes are freezed, non-boot cpus and interrupts are disabled 521 521 + * that means processes are frozen, non-boot cpus and interrupts are disabled 522 522 * now. It is therefore possible to start the suspend timer without taking the 523 523 * clocksource mutex. 524 524 */

+9 -9

kernel/time/hrtimer.c

reviewed

··· 683 683 * T1 is removed, so this code is called and would reprogram 684 684 * the hardware to 5s from now. Any hrtimer_start after that 685 685 * will not reprogram the hardware due to hang_detected being 686 686 - * set. So we'd effectivly block all timers until the T2 event 686 686 + * set. So we'd effectively block all timers until the T2 event 687 687 * fires. 688 688 */ 689 689 if (!__hrtimer_hres_active(cpu_base) || cpu_base->hang_detected) ··· 1019 1019 * cpu_base->next_timer. This happens when we remove the first 1020 1020 * timer on a remote cpu. No harm as we never dereference 1021 1021 * cpu_base->next_timer. So the worst thing what can happen is 1022 1022 - * an superflous call to hrtimer_force_reprogram() on the 1022 1022 + * an superfluous call to hrtimer_force_reprogram() on the 1023 1023 * remote cpu later on if the same timer gets enqueued again. 1024 1024 */ 1025 1025 if (reprogram && timer == cpu_base->next_timer) ··· 1212 1212 * The counterpart to hrtimer_cancel_wait_running(). 1213 1213 * 1214 1214 * If there is a waiter for cpu_base->expiry_lock, then it was waiting for 1215 1215 - * the timer callback to finish. Drop expiry_lock and reaquire it. That 1215 1215 + * the timer callback to finish. Drop expiry_lock and reacquire it. That 1216 1216 * allows the waiter to acquire the lock and make progress. 1217 1217 */ 1218 1218 static void hrtimer_sync_wait_running(struct hrtimer_cpu_base *cpu_base, ··· 1398 1398 int base; 1399 1399 1400 1400 /* 1401 1401 - * On PREEMPT_RT enabled kernels hrtimers which are not explicitely 1401 1401 + * On PREEMPT_RT enabled kernels hrtimers which are not explicitly 1402 1402 * marked for hard interrupt expiry mode are moved into soft 1403 1403 * interrupt context for latency reasons and because the callbacks 1404 1404 * can invoke functions which might sleep on RT, e.g. spin_lock(). ··· 1430 1430 * hrtimer_init - initialize a timer to the given clock 1431 1431 * @timer: the timer to be initialized 1432 1432 * @clock_id: the clock to be used 1433 1433 - * @mode: The modes which are relevant for intitialization: 1433 1433 + * @mode: The modes which are relevant for initialization: 1434 1434 * HRTIMER_MODE_ABS, HRTIMER_MODE_REL, HRTIMER_MODE_ABS_SOFT, 1435 1435 * HRTIMER_MODE_REL_SOFT 1436 1436 * ··· 1487 1487 * insufficient for that. 1488 1488 * 1489 1489 * The sequence numbers are required because otherwise we could still observe 1490 1490 - * a false negative if the read side got smeared over multiple consequtive 1490 1490 + * a false negative if the read side got smeared over multiple consecutive 1491 1491 * __run_hrtimer() invocations. 1492 1492 */ 1493 1493 ··· 1588 1588 * minimizing wakeups, not running timers at the 1589 1589 * earliest interrupt after their soft expiration. 1590 1590 * This allows us to avoid using a Priority Search 1591 1591 - * Tree, which can answer a stabbing querry for 1591 1591 + * Tree, which can answer a stabbing query for 1592 1592 * overlapping intervals and instead use the simple 1593 1593 * BST we already have. 1594 1594 * We don't add extra wakeups by delaying timers that ··· 1822 1822 clockid_t clock_id, enum hrtimer_mode mode) 1823 1823 { 1824 1824 /* 1825 1825 - * On PREEMPT_RT enabled kernels hrtimers which are not explicitely 1825 1825 + * On PREEMPT_RT enabled kernels hrtimers which are not explicitly 1826 1826 * marked for hard interrupt expiry mode are moved into soft 1827 1827 * interrupt context either for latency reasons or because the 1828 1828 * hrtimer callback takes regular spinlocks or invokes other ··· 1835 1835 * the same CPU. That causes a latency spike due to the wakeup of 1836 1836 * a gazillion threads. 1837 1837 * 1838 1838 - * OTOH, priviledged real-time user space applications rely on the 1838 1838 + * OTOH, privileged real-time user space applications rely on the 1839 1839 * low latency of hard interrupt wakeups. If the current task is in 1840 1840 * a real-time scheduling class, mark the mode for hard interrupt 1841 1841 * expiry.

+1 -1

kernel/time/jiffies.c

reviewed

··· 44 44 * the timer interrupt frequency HZ and it suffers 45 45 * inaccuracies caused by missed or lost timer 46 46 * interrupts and the inability for the timer 47 47 - * interrupt hardware to accuratly tick at the 47 47 + * interrupt hardware to accurately tick at the 48 48 * requested HZ value. It is also not recommended 49 49 * for "tick-less" systems. 50 50 */

+1 -1

kernel/time/ntp.c

reviewed

··· 544 544 struct timespec64 *to_set, 545 545 const struct timespec64 *now) 546 546 { 547 547 - /* Allowed error in tv_nsec, arbitarily set to 5 jiffies in ns. */ 547 547 + /* Allowed error in tv_nsec, arbitrarily set to 5 jiffies in ns. */ 548 548 const unsigned long TIME_SET_NSEC_FUZZ = TICK_NSEC * 5; 549 549 struct timespec64 delay = {.tv_sec = -1, 550 550 .tv_nsec = set_offset_nsec};

+3 -3

kernel/time/posix-cpu-timers.c

reviewed

··· 279 279 * @tsk: Task for which cputime needs to be started 280 280 * @samples: Storage for time samples 281 281 * 282 282 - * The thread group cputime accouting is avoided when there are no posix 282 282 + * The thread group cputime accounting is avoided when there are no posix 283 283 * CPU timers armed. Before starting a timer it's required to check whether 284 284 * the time accounting is active. If not, a full update of the atomic 285 285 * accounting store needs to be done and the accounting enabled. ··· 390 390 /* 391 391 * If posix timer expiry is handled in task work context then 392 392 * timer::it_lock can be taken without disabling interrupts as all 393 393 - * other locking happens in task context. This requires a seperate 393 393 + * other locking happens in task context. This requires a separate 394 394 * lock class key otherwise regular posix timer expiry would record 395 395 * the lock class being taken in interrupt context and generate a 396 396 * false positive warning. ··· 1216 1216 check_process_timers(tsk, &firing); 1217 1217 1218 1218 /* 1219 1219 - * The above timer checks have updated the exipry cache and 1219 1219 + * The above timer checks have updated the expiry cache and 1220 1220 * because nothing can have queued or modified timers after 1221 1221 * sighand lock was taken above it is guaranteed to be 1222 1222 * consistent. So the next timer interrupt fastpath check

+1 -1

kernel/time/tick-broadcast-hrtimer.c

reviewed

··· 53 53 * reasons. 54 54 * 55 55 * Each caller tries to arm the hrtimer on its own CPU, but if the 56 56 - * hrtimer callbback function is currently running, then 56 56 + * hrtimer callback function is currently running, then 57 57 * hrtimer_start() cannot move it and the timer stays on the CPU on 58 58 * which it is assigned at the moment. 59 59 *

+2 -2

kernel/time/tick-broadcast.c

reviewed

··· 157 157 } 158 158 159 159 /* 160 160 - * Check, if the device is disfunctional and a place holder, which 160 160 + * Check, if the device is dysfunctional and a placeholder, which 161 161 * needs to be handled by the broadcast device. 162 162 */ 163 163 int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu) ··· 391 391 * - the broadcast device exists 392 392 * - the broadcast device is not a hrtimer based one 393 393 * - the broadcast device is in periodic mode to 394 394 - * avoid a hickup during switch to oneshot mode 394 394 + * avoid a hiccup during switch to oneshot mode 395 395 */ 396 396 if (bc && !(bc->features & CLOCK_EVT_FEAT_HRTIMER) && 397 397 tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)

+1 -1

kernel/time/tick-oneshot.c

reviewed

··· 45 45 } 46 46 47 47 /** 48 48 - * tick_resume_onshot - resume oneshot mode 48 48 + * tick_resume_oneshot - resume oneshot mode 49 49 */ 50 50 void tick_resume_oneshot(void) 51 51 {

+1 -1

kernel/time/tick-sched.c

reviewed

··· 751 751 * Aside of that check whether the local timer softirq is 752 752 * pending. If so its a bad idea to call get_next_timer_interrupt() 753 753 * because there is an already expired timer, so it will request 754 754 - * immeditate expiry, which rearms the hardware timer with a 754 754 + * immediate expiry, which rearms the hardware timer with a 755 755 * minimal delta which brings us back to this place 756 756 * immediately. Lather, rinse and repeat... 757 757 */

+1 -1

kernel/time/tick-sched.h

reviewed

··· 29 29 * @inidle: Indicator that the CPU is in the tick idle mode 30 30 * @tick_stopped: Indicator that the idle tick has been stopped 31 31 * @idle_active: Indicator that the CPU is actively in the tick idle mode; 32 32 - * it is resetted during irq handling phases. 32 32 + * it is reset during irq handling phases. 33 33 * @do_timer_lst: CPU was the last one doing do_timer before going idle 34 34 * @got_idle_tick: Tick timer function has run with @inidle set 35 35 * @last_tick: Store the last tick expiry time when the tick

+1 -1

kernel/time/time.c

reviewed

··· 571 571 /* 572 572 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note 573 573 * that a remainder subtract here would not do the right thing as the 574 574 - * resolution values don't fall on second boundries. I.e. the line: 574 574 + * resolution values don't fall on second boundaries. I.e. the line: 575 575 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding. 576 576 * Note that due to the small error in the multiplier here, this 577 577 * rounding is incorrect for sufficiently large values of tv_nsec, but

+5 -5

kernel/time/timekeeping.c

reviewed

··· 596 596 * careful cache layout of the timekeeper because the sequence count and 597 597 * struct tk_read_base would then need two cache lines instead of one. 598 598 * 599 599 - * Access to the time keeper clock source is disabled accross the innermost 599 599 + * Access to the time keeper clock source is disabled across the innermost 600 600 * steps of suspend/resume. The accessors still work, but the timestamps 601 601 * are frozen until time keeping is resumed which happens very early. 602 602 * 603 603 * For regular suspend/resume there is no observable difference vs. sched 604 604 * clock, but it might affect some of the nasty low level debug printks. 605 605 * 606 606 - * OTOH, access to sched clock is not guaranteed accross suspend/resume on 606 606 + * OTOH, access to sched clock is not guaranteed across suspend/resume on 607 607 * all systems either so it depends on the hardware in use. 608 608 * 609 609 * If that turns out to be a real problem then this could be mitigated by ··· 899 899 EXPORT_SYMBOL_GPL(ktime_get_coarse_with_offset); 900 900 901 901 /** 902 902 - * ktime_mono_to_any() - convert mononotic time to any other time 902 902 + * ktime_mono_to_any() - convert monotonic time to any other time 903 903 * @tmono: time to convert. 904 904 * @offs: which offset to use 905 905 */ ··· 1948 1948 * xtime_nsec_1 = offset + xtime_nsec_2 1949 1949 * Which gives us: 1950 1950 * xtime_nsec_2 = xtime_nsec_1 - offset 1951 1951 - * Which simplfies to: 1951 1951 + * Which simplifies to: 1952 1952 * xtime_nsec -= offset 1953 1953 */ 1954 1954 if ((mult_adj > 0) && (tk->tkr_mono.mult + mult_adj < mult_adj)) { ··· 2336 2336 2337 2337 /* 2338 2338 * Validate if a timespec/timeval used to inject a time 2339 2339 - * offset is valid. Offsets can be postive or negative, so 2339 2339 + * offset is valid. Offsets can be positive or negative, so 2340 2340 * we don't check tv_sec. The value of the timeval/timespec 2341 2341 * is the sum of its fields,but *NOTE*: 2342 2342 * The field tv_usec/tv_nsec must always be non-negative and

+2 -2

kernel/time/timer.c

reviewed

··· 894 894 /* 895 895 * No need to forward if we are close enough below jiffies. 896 896 * Also while executing timers, base->clk is 1 offset ahead 897 897 - * of jiffies to avoid endless requeuing to current jffies. 897 897 + * of jiffies to avoid endless requeuing to current jiffies. 898 898 */ 899 899 if ((long)(jnow - base->clk) < 1) 900 900 return; ··· 1271 1271 * The counterpart to del_timer_wait_running(). 1272 1272 * 1273 1273 * If there is a waiter for base->expiry_lock, then it was waiting for the 1274 1274 - * timer callback to finish. Drop expiry_lock and reaquire it. That allows 1274 1274 + * timer callback to finish. Drop expiry_lock and reacquire it. That allows 1275 1275 * the waiter to acquire the lock and make progress. 1276 1276 */ 1277 1277 static void timer_sync_wait_running(struct timer_base *base)

+1 -1

kernel/time/vsyscall.c

reviewed

··· 108 108 109 109 /* 110 110 * If the current clocksource is not VDSO capable, then spare the 111 111 - * update of the high reolution parts. 111 111 + * update of the high resolution parts. 112 112 */ 113 113 if (clock_mode != VDSO_CLOCKMODE_NONE) 114 114 update_vdso_data(vdata, tk);

+2 -2

tools/testing/selftests/timers/clocksource-switch.c

reviewed

··· 3 3 * (C) Copyright IBM 2012 4 4 * Licensed under the GPLv2 5 5 * 6 6 - * NOTE: This is a meta-test which quickly changes the clocksourc and 6 6 + * NOTE: This is a meta-test which quickly changes the clocksource and 7 7 * then uses other tests to detect problems. Thus this test requires 8 8 * that the inconsistency-check and nanosleep tests be present in the 9 9 * same directory it is run from. ··· 134 134 return -1; 135 135 } 136 136 137 137 - /* Check everything is sane before we start switching asyncrhonously */ 137 137 + /* Check everything is sane before we start switching asynchronously */ 138 138 for (i = 0; i < count; i++) { 139 139 printf("Validating clocksource %s\n", clocksource_list[i]); 140 140 if (change_clocksource(clocksource_list[i])) {

+1 -1

tools/testing/selftests/timers/leap-a-day.c

reviewed

··· 5 5 * Licensed under the GPLv2 6 6 * 7 7 * This test signals the kernel to insert a leap second 8 8 - * every day at midnight GMT. This allows for stessing the 8 8 + * every day at midnight GMT. This allows for stressing the 9 9 * kernel's leap-second behavior, as well as how well applications 10 10 * handle the leap-second discontinuity. 11 11 *

+2 -2

tools/testing/selftests/timers/leapcrash.c

reviewed

··· 4 4 * (C) Copyright 2013, 2015 Linaro Limited 5 5 * Licensed under the GPL 6 6 * 7 7 - * This test demonstrates leapsecond deadlock that is possibe 7 7 + * This test demonstrates leapsecond deadlock that is possible 8 8 * on kernels from 2.6.26 to 3.3. 9 9 * 10 10 - * WARNING: THIS WILL LIKELY HARDHANG SYSTEMS AND MAY LOSE DATA 10 10 + * WARNING: THIS WILL LIKELY HARD HANG SYSTEMS AND MAY LOSE DATA 11 11 * RUN AT YOUR OWN RISK! 12 12 * To build: 13 13 * $ gcc leapcrash.c -o leapcrash -lrt

+1 -1

tools/testing/selftests/timers/threadtest.c

reviewed

··· 76 76 77 77 /* The shared thread shares a global list 78 78 * that each thread fills while holding the lock. 79 79 - * This stresses clock syncronization across cpus. 79 79 + * This stresses clock synchronization across cpus. 80 80 */ 81 81 void *shared_thread(void *arg) 82 82 {