diff --git a/hal/lib/Athena/Notifier.cpp b/hal/lib/Athena/Notifier.cpp
index c2c6c4c..2184b5a 100644
--- a/hal/lib/Athena/Notifier.cpp
+++ b/hal/lib/Athena/Notifier.cpp
@@ -1,3 +1,10 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2016. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
 #include "HAL/Notifier.hpp"
 #include "ChipObject.h"
 #include "HAL/HAL.hpp"
@@ -12,12 +19,12 @@
 static priority_recursive_mutex notifierMutex;
 static tAlarm *notifierAlarm = nullptr;
 static tInterruptManager *notifierManager = nullptr;
-static uint32_t closestTrigger = UINT32_MAX;
+static uint64_t closestTrigger = UINT64_MAX;
 struct Notifier {
 	Notifier *prev, *next;
 	void *param;
-	void (*process)(uint32_t, void*);
-	uint32_t triggerTime = UINT32_MAX;
+	void (*process)(uint64_t, void*);
+	uint64_t triggerTime = UINT64_MAX;
 };
 static Notifier *notifiers = nullptr;
 static std::atomic_flag notifierAtexitRegistered = ATOMIC_FLAG_INIT;
@@ -28,19 +35,19 @@
 	std::unique_lock<priority_recursive_mutex> sync(notifierMutex);
 
 	int32_t status = 0;
-	uint32_t currentTime = 0;
+	uint64_t currentTime = 0;
 
 	// the hardware disables itself after each alarm
-	closestTrigger = UINT32_MAX;
+	closestTrigger = UINT64_MAX;
 
 	// process all notifiers
 	Notifier *notifier = notifiers;
 	while (notifier) {
-		if (notifier->triggerTime != UINT32_MAX) {
+		if (notifier->triggerTime != UINT64_MAX) {
 			if (currentTime == 0)
 				currentTime = getFPGATime(&status);
 			if (notifier->triggerTime < currentTime) {
-				notifier->triggerTime = UINT32_MAX;
+				notifier->triggerTime = UINT64_MAX;
 				auto process = notifier->process;
 				auto param = notifier->param;
 				sync.unlock();
@@ -59,9 +66,11 @@
 	notifierManager = nullptr;
 }
 
-void* initializeNotifier(void (*ProcessQueue)(uint32_t, void*), void *param, int32_t *status)
+extern "C" {
+
+void* initializeNotifier(void (*process)(uint64_t, void*), void *param, int32_t *status)
 {
-	if (!ProcessQueue) {
+	if (!process) {
 		*status = NULL_PARAMETER;
 		return nullptr;
 	}
@@ -85,7 +94,7 @@
 	notifier->next = notifiers;
 	if (notifier->next) notifier->next->prev = notifier;
 	notifier->param = param;
-	notifier->process = ProcessQueue;
+	notifier->process = process;
 	notifiers = notifier;
 	return notifier;
 }
@@ -119,25 +128,40 @@
 	}
 }
 
-void updateNotifierAlarm(void* notifier_pointer, uint32_t triggerTime, int32_t *status)
+void* getNotifierParam(void* notifier_pointer, int32_t *status)
+{
+	return ((Notifier*)notifier_pointer)->param;
+}
+
+void updateNotifierAlarm(void* notifier_pointer, uint64_t triggerTime, int32_t *status)
 {
 	std::lock_guard<priority_recursive_mutex> sync(notifierMutex);
 
 	Notifier* notifier = (Notifier*)notifier_pointer;
 	notifier->triggerTime = triggerTime;
-	bool wasActive = (closestTrigger != UINT32_MAX);
+	bool wasActive = (closestTrigger != UINT64_MAX);
 
-        if (!notifierInterruptMutex.try_lock() || notifierRefCount == 0 ||
-            !notifierAlarm)
-          return;
+	if (!notifierInterruptMutex.try_lock() || notifierRefCount == 0 ||
+			!notifierAlarm)
+		return;
 
-        // Update alarm time if closer than current.
+	// Update alarm time if closer than current.
 	if (triggerTime < closestTrigger) {
 		closestTrigger = triggerTime;
-		notifierAlarm->writeTriggerTime(triggerTime, status);
+		// Simply truncate the hardware trigger time to 32-bit.
+		notifierAlarm->writeTriggerTime((uint32_t)triggerTime, status);
 	}
 	// Enable the alarm.  The hardware disables itself after each alarm.
 	if (!wasActive) notifierAlarm->writeEnable(true, status);
 
 	notifierInterruptMutex.unlock();
 }
+
+void stopNotifierAlarm(void* notifier_pointer, int32_t *status)
+{
+	std::lock_guard<priority_recursive_mutex> sync(notifierMutex);
+	Notifier* notifier = (Notifier*)notifier_pointer;
+	notifier->triggerTime = UINT64_MAX;
+}
+
+}  // extern "C"