diff --git a/os/hal/include/rtc.h b/os/hal/include/rtc.h
index aa2562c69..1264c5bd8 100644
--- a/os/hal/include/rtc.h
+++ b/os/hal/include/rtc.h
@@ -35,6 +35,18 @@
 /* Driver constants.                                                         */
 /*===========================================================================*/
 
+/**
+ * @name    Date/Time bit masks
+ * @{
+ */
+#define RTC_TIME_SECONDS_MASK   0x0000001F  /* @brief Seconds mask.         */
+#define RTC_TIME_MINUTES_MASK   0x000007E0  /* @brief Minutes mask.         */
+#define RTC_TIME_HOURS_MASK     0x0000F800  /* @brief Hours mask.           */
+#define RTC_DATE_DAYS_MASK      0x001F0000  /* @brief Days mask.            */
+#define RTC_DATE_MONTHS_MASK    0x01E00000  /* @brief Months mask.          */
+#define RTC_DATE_YEARS_MASK     0xFE000000  /* @brief Years mask.           */
+/** @} */
+
 /*===========================================================================*/
 /* Driver pre-compile time settings.                                         */
 /*===========================================================================*/
@@ -53,9 +65,9 @@
 typedef struct RTCDriver RTCDriver;
 
 /**
- * @brief   Type of an RTC callback.
+ * @brief   Type of a structure representing an RTC time stamp.
  */
-typedef void (*rtccb_t)(RTCDriver *rtcp);
+typedef struct RTCTime RTCTime;
 
 #include "rtc_lld.h"
 
@@ -71,14 +83,17 @@ typedef void (*rtccb_t)(RTCDriver *rtcp);
 extern "C" {
 #endif
   void rtcInit(void);
+  void rtcSetTime(RTCDriver *rtcp, const RTCTime *timespec);
+  void rtcGetTime(RTCDriver *rtcp, RTCTime *timespec);
+#if RTC_ALARMS > 0
+  void rtcSetAlarm(RTCDriver *rtcp,
+                   rtcalarm_t alarm,
+                   const RTCAlarm *alarmspec);
+  void rtcGetAlarm(RTCDriver *rtcp, rtcalarm_t alarm, RTCAlarm *alarmspec);
+#endif
 #if RTC_SUPPORTS_CALLBACKS
-  void rtcSetCallback(RTCDriver *rtcp, rtccb_t overflowcb,
-                      rtccb_t secondcb, rtccb_t alarmcb);
-#endif /* RTC_SUPPORTS_CALLBACKS */
-  void rtcSetTime(RTCDateTime *timespec);
-  void rtcGetTime(RTCDateTime *timespec);
-  void rtcSetAlarm(RTCDateTime *timespec);
-  void rtcGetAlarm(RTCDateTime *timespec);
+  void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback);
+#endif
 #ifdef __cplusplus
 }
 #endif
diff --git a/os/hal/platforms/STM32/RTCv1/rtc_lld.c b/os/hal/platforms/STM32/RTCv1/rtc_lld.c
index df90bcc11..2876b990d 100644
--- a/os/hal/platforms/STM32/RTCv1/rtc_lld.c
+++ b/os/hal/platforms/STM32/RTCv1/rtc_lld.c
@@ -29,16 +29,16 @@
 #include "ch.h"
 #include "hal.h"
 
-
 #if HAL_USE_RTC || defined(__DOXYGEN__)
 
 /*===========================================================================*/
 /* Driver exported variables.                                                */
 /*===========================================================================*/
 
-/** @brief RTC driver identifier.*/
-RTCDriver RTCD;
-
+/**
+ * @brief RTC driver identifier.
+ */
+RTCDriver RTCD1;
 
 /*===========================================================================*/
 /* Driver local variables.                                                   */
@@ -55,33 +55,37 @@ RTCDriver RTCD;
  *
  * @notapi
  */
-#if RTC_SUPPORTS_CALLBACKS
+static void rtc_lld_serve_interrupt(RTCDriver *rtcp) {
 
-static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
   chSysLockFromIsr();
 
-  if ((RTC->CRH & RTC_CRH_SECIE) && \
-      (RTC->CRL & RTC_CRL_SECF) && \
-      (rtcp->second_cb != NULL)){
-    rtcp->second_cb(rtcp);
+  if ((RTC->CRH & RTC_CRH_SECIE) && (RTC->CRL & RTC_CRL_SECF)) {
+    rtcp->rtc_cb(rtcp, RTC_EVENT_SECOND);
     RTC->CRL &= ~RTC_CRL_SECF;
   }
-  if ((RTC->CRH & RTC_CRH_ALRIE) && \
-      (RTC->CRL & RTC_CRL_ALRF) && \
-      (rtcp->alarm_cb != NULL)){
-    rtcp->alarm_cb(rtcp);
+  if ((RTC->CRH & RTC_CRH_ALRIE) && (RTC->CRL & RTC_CRL_ALRF)) {
+    rtcp->rtc_cb(rtcp, RTC_EVENT_ALARM);
     RTC->CRL &= ~RTC_CRL_ALRF;
   }
-  if ((RTC->CRH & RTC_CRH_OWIE) && \
-      (RTC->CRL & RTC_CRL_OWF) && \
-      (rtcp->overflow_cb != NULL)){
-    rtcp->overflow_cb(rtcp);
+  if ((RTC->CRH & RTC_CRH_OWIE) && (RTC->CRL & RTC_CRL_OWF)) {
+    rtcp->rtc_cb(rtcp, RTC_EVENT_OVERFLOW);
     RTC->CRL &= ~RTC_CRL_OWF;
   }
 
   chSysUnlockFromIsr();
 }
-#endif /* RTC_SUPPORTS_CALLBACKS */
+
+/**
+ * @brief   Waits for the previous registers write to finish.
+ *
+ * @notapi
+ */
+static void rtc_lld_wait_write(void) {
+
+  /* Waits registers write completion.*/
+  while (!(RTC->CRL & RTC_CRL_RTOFF))
+    ;
+}
 
 /*===========================================================================*/
 /* Driver interrupt handlers.                                                */
@@ -89,18 +93,18 @@ static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
 
 /**
  * @brief   RTC interrupt handler.
+ *
  * @isr
  */
-#if RTC_SUPPORTS_CALLBACKS
-
 CH_IRQ_HANDLER(RTC_IRQHandler) {
+
   CH_IRQ_PROLOGUE();
-  rtc_lld_serve_interrupt(&RTCD);
+
+  rtc_lld_serve_interrupt(&RTCD1);
+
   CH_IRQ_EPILOGUE();
 }
 
-#endif /* RTC_SUPPORTS_CALLBACKS */
-
 /*===========================================================================*/
 /* Driver exported functions.                                                */
 /*===========================================================================*/
@@ -108,226 +112,207 @@ CH_IRQ_HANDLER(RTC_IRQHandler) {
 /**
  * @brief   Enable access to registers and initialize RTC if BKP domain
  *          was previously reseted.
- *
  * @note:   Cold start time of LSE oscillator on STM32 platform 
  *          takes about 3 seconds.
  *
  * @notapi
  */
 void rtc_lld_init(void){
-  uint32_t preload = 0;
+  uint32_t preload;
 
   rccEnableBKPInterface(FALSE);
 
-  /* enable access to BKP registers */
+  /* Enables access to BKP registers.*/
   PWR->CR |= PWR_CR_DBP;
-  /* select clock source */
-  RCC->BDCR |= STM32_RTC;
+
+  /* If the RTC is not enabled then performs a reset of the backup domain.*/
+  if (!(RCC->BDCR & RCC_BDCR_RTCEN)) {
+    RCC->BDCR = RCC_BDCR_BDRST;
+    RCC->BDCR = 0;
+  }
 
 #if STM32_RTC == STM32_RTC_LSE
-    if (! ((RCC->BDCR & RCC_BDCR_RTCEN) || (RCC->BDCR & RCC_BDCR_LSEON))){
-      RCC->BDCR |= RCC_BDCR_LSEON; 
-      while(!(RCC->BDCR & RCC_BDCR_LSERDY))
-        ;
-      RCC->BDCR |= RCC_BDCR_RTCEN;
-    }
-    preload = STM32_LSECLK - 1;
-
+  if (!(RCC->BDCR & RCC_BDCR_LSEON)) {
+    RCC->BDCR |= RCC_BDCR_LSEON;
+    while (!(RCC->BDCR & RCC_BDCR_LSERDY))
+      ;
+  }
+  preload = STM32_LSECLK - 1;
 #elif STM32_RTC == STM32_RTC_LSI
-    RCC->CSR  |= RCC_CSR_LSION;
-    while(!(RCC->CSR & RCC_CSR_LSIRDY))
-      ;
-    /* According to errata sheet we must wait additional 100 uS for stabilization */
-    uint32_t tmo = (STM32_SYSCLK / 1000000 ) * 100;
-    while(tmo--)
-      ;
-    RCC->BDCR |= RCC_BDCR_RTCEN;
-    preload = STM32_LSICLK - 1;
-
+  /* TODO: Move the LSI clock initialization in the HAL low level driver.*/
+  RCC->CSR |= RCC_CSR_LSION;
+  while (!(RCC->CSR & RCC_CSR_LSIRDY))
+    ;
+  /* According to errata sheet we must wait additional 100 uS for
+     stabilization.
+     TODO: Change this code, software loops are not reliable.*/
+  uint32_t tmo = (STM32_SYSCLK / 1000000) * 100;
+  while (tmo--)
+    ;
+  preload = STM32_LSICLK - 1;
 #elif STM32_RTC == STM32_RTC_HSE
-    preload = (STM32_HSICLK / 128) - 1;
-
-#else
-#error "RTC clock source not selected"
+  preload = (STM32_HSICLK / 128) - 1;
 #endif
 
+  /* Selects clock source (previously enabled and stabilized.*/
+  RCC->BDCR = (RCC->BDCR & ~RCC_BDCR_RTCSEL) | STM32_RTC;
+
+  /* RTC enabled regardless its previous status.*/
+  RCC->BDCR |= RCC_BDCR_RTCEN;
+
   /* Ensure that RTC_CNT and RTC_DIV contain actual values after enabling
-   * clocking on APB1, because these values only update when APB1 functioning.*/
-  RTC->CRL &= ~(RTC_CRL_RSF);
+     clocking on APB1, because these values only update when APB1
+     functioning.*/
+  RTC->CRL = 0;
   while (!(RTC->CRL & RTC_CRL_RSF))
     ;
 
-  /* Write preload register only if its value changed */
-  if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + RTC->PRLL)){
-    while(!(RTC->CRL & RTC_CRL_RTOFF))
-      ;
+  /* Write preload register only if its value differs.*/
+  if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + (uint32_t)RTC->PRLL)) {
 
-    RTC->CRL |= RTC_CRL_CNF;                            /* switch on configure mode */
-    RTC->PRLH = (uint16_t)((preload >> 16) & 0b1111);   /* write preloader */
+    rtc_lld_wait_write();
+
+    /* Enters configuration mode and writes PRLx registers then leaves the
+       configuration mode.*/
+    RTC->CRL |= RTC_CRL_CNF;
+    RTC->PRLH = (uint16_t)(preload >> 16);
     RTC->PRLL = (uint16_t)(preload & 0xFFFF);
-    RTC->CRL &= ~RTC_CRL_CNF;                           /* switch off configure mode */
-
-    while(!(RTC->CRL & RTC_CRL_RTOFF))                  /* wait for completion */
-      ;
+    RTC->CRL &= ~RTC_CRL_CNF;
   }
 
-  /* disable all interrupts and clear all even flags just to be safe */
-  RTC->CRH &= ~(RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE);
-  RTC->CRL &= ~(RTC_CRL_SECF | RTC_CRL_ALRF  | RTC_CRL_OWF);
+  /* All interrupts initially disabled.*/
+  RTC->CRH = 0;
 
-#if RTC_SUPPORTS_CALLBACKS
-  RTCD.alarm_cb    = NULL;
-  RTCD.overflow_cb = NULL;
-  RTCD.second_cb   = NULL;
-#endif /* RTC_SUPPORTS_CALLBACKS */
+  /* Callback initially disabled.*/
+  RTCD1.rtc_cb = NULL;
 }
 
 /**
- * @brief     Enables and disables callbacks on the fly.
+ * @brief   Set current time.
+ * @note    Fractional part will be silently ignored. There is no possibility
+ *          to change it on STM32F1xx platform.
  *
- * @details   Pass callback function(s) in argument(s) to enable callback(s).
- *            Pass NULL to disable callback.
- *
- * @pre       To use this function you must set @p RTC_SUPPORTS_CALLBACKS
- *            to @p TRUE.
- *
- * @param[in] rtcp         pointer to RTC driver structure.
- * @param[in] overflowcb   overflow callback function.
- * @param[in] secondcb     every second callback function.
- * @param[in] alarmcb      alarm callback function.
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] timespec  pointer to a @p RTCTime structure
  *
  * @notapi
  */
-#if RTC_SUPPORTS_CALLBACKS
-void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflowcb,
-                          rtccb_t secondcb, rtccb_t alarmcb){
+void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec) {
 
-  uint16_t isr_flags = 0;
+  (void)rtcp;
 
-  if (overflowcb != NULL){
-    rtcp->overflow_cb = *overflowcb;
-    isr_flags |= RTC_CRH_OWIE;
-  }
-  else{
-    rtcp->overflow_cb = NULL;
-    isr_flags &= ~RTC_CRH_OWIE;
-  }
+  rtc_lld_wait_write();
 
-  if (alarmcb != NULL){
-    rtcp->alarm_cb = *alarmcb;
-    isr_flags |= RTC_CRH_ALRIE;
-  }
-  else{
-    rtcp->alarm_cb = NULL;
-    isr_flags &= ~RTC_CRH_ALRIE;
-  }
-
-  if (secondcb != NULL){
-    rtcp->second_cb = *secondcb;
-    isr_flags |= RTC_CRH_SECIE;
-  }
-  else{
-    rtcp->second_cb = NULL;
-    isr_flags &= ~RTC_CRH_SECIE;
-  }
-
-  if(isr_flags != 0){
-    NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY));
-    RTC->CRH |= isr_flags;
-  }
-  else{
-    NVICDisableVector(RTC_IRQn);
-    RTC->CRH = 0;
-  }
-}
-#endif /* RTC_SUPPORTS_CALLBACKS */
-
-/**
- * @brief     Set current time.
- *
- * @param[in] timespec     pointer to variable storing time.
- *
- * @note      Fractional part will be silently ignored. There is no possibility
- *            to change it on STM32F1xx platform.
- * @notapi
- */
-void rtc_lld_set_time(RTCDateTime *timespec){
-
-  while(!(RTC->CRL & RTC_CRL_RTOFF))
-    ;
-
-  RTC->CRL |= RTC_CRL_CNF;                            /* switch on configure mode */
-  RTC->CNTH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF);
+  RTC->CRL |= RTC_CRL_CNF;
+  RTC->CNTH = (uint16_t)(timespec->tv_sec >> 16);
   RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF);
-  RTC->CRL &= ~RTC_CRL_CNF;                           /* switch off configure mode */
-
-  while(!(RTC->CRL & RTC_CRL_RTOFF))                  /* wait for completion */
-    ;
+  RTC->CRL &= ~RTC_CRL_CNF;
 }
 
 /**
- * @brief     Get current time.
+ * @brief   Get current time.
  *
- * @param[in] msec     pointer to variable for storing fractional part of
- *                     time (milliseconds).
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[out] timespec pointer to a @p RTCTime structure
  *
  * @notapi
  */
-inline void rtc_lld_get_time(RTCDateTime *timespec){
-  uint32_t time_frac = 0;
-  time_frac = (((uint32_t)RTC->DIVH) << 16) + (RTC->DIVL);
+void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec) {
+  uint32_t time_frac;
 
-  timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) / STM32_LSECLK);
+  (void)rtcp;
+
+  time_frac = (((uint32_t)RTC->DIVH) << 16) + (uint32_t)RTC->DIVL;
+  timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) /
+                                 STM32_LSECLK);
   timespec->tv_sec = (RTC->CNTH << 16) + RTC->CNTL;
 }
 
 /**
- * @brief     Set alarm time.
- *
- * @param[in] timespec     pointer to variable storing time of alarm.
- *
- * @note      Fractional part will be silently ignored. There is no possibility
- *            to change it on STM32F1xx platform.
+ * @brief   Set alarm time.
  *
  * @note      Default value after BKP domain reset is 0xFFFFFFFF
  *
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] alarm     alarm identifier
+ * @param[in] alarmspec pointer to a @p RTCAlarm structure
+ *
  * @notapi
  */
-void rtc_lld_set_alarm(RTCDateTime *timespec){
+void rtc_lld_set_alarm(RTCDriver *rtcp,
+                       rtcalarm_t alarm,
+                       const RTCAlarm *alarmspec) {
 
-  while(!(RTC->CRL & RTC_CRL_RTOFF))
-    ;
+  (void)rtcp;
+  (void)alarm;
 
-  RTC->CRL |= RTC_CRL_CNF;                            /* switch on configure mode */
-  RTC->ALRH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF);
-  RTC->ALRL = (uint16_t)(timespec->tv_sec & 0xFFFF);
-  RTC->CRL &= ~RTC_CRL_CNF;                           /* switch off configure mode */
+  rtc_lld_wait_write();
 
-#if !(RTC_SUPPORTS_CALLBACKS)
-  RTC->CRL &= ~RTC_CRL_ALRF;
-  RTC->CRH |= RTC_CRH_ALRIE;
-#endif /* !(RTC_SUPPORTS_CALLBACKS) */
-
-  while(!(RTC->CRL & RTC_CRL_RTOFF))                  /* wait for completion */
-    ;
+  /* Enters configuration mode and writes ALRHx registers then leaves the
+     configuration mode.*/
+  RTC->CRL |= RTC_CRL_CNF;
+  if (alarmspec != NULL) {
+    RTC->ALRH = (uint16_t)(alarmspec->tv_sec >> 16);
+    RTC->ALRL = (uint16_t)(alarmspec->tv_sec & 0xFFFF);
+  }
+  else {
+    RTC->ALRH = 0;
+    RTC->ALRL = 0;
+  }
+  RTC->CRL &= ~RTC_CRL_CNF;
 }
 
 /**
- * @brief Get current alarm time.
+ * @brief   Get current alarm.
+ * @note    If an alarm has not been set then the returned alarm specification
+ *          is not meaningful.
  *
- * @param[in] timespec     pointer to variable storing time of alarm.
+ * @note    Default value after BKP domain reset is 0xFFFFFFFF.
  *
- * @note      Fractional part will be silently ignored. There is no possibility
- *            to change it on STM32F1xx platform.
- *
- * @note      Default value after BKP domain reset is 0xFFFFFFFF
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] alarm     alarm identifier
+ * @param[out] alarmspec pointer to a @p RTCAlarm structure
  *
  * @notapi
  */
-inline void rtc_lld_get_alarm(RTCDateTime *timespec){
-  timespec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL);
+void rtc_lld_get_alarm(RTCDriver *rtcp,
+                       rtcalarm_t alarm,
+                       RTCAlarm *alarmspec) {
+
+  (void)rtcp;
+  (void)alarm;
+
+  alarmspec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL);
 }
 
+/**
+ * @brief   Enables or disables RTC callbacks.
+ * @details This function enables or disables callbacks, use a @p NULL pointer
+ *          in order to disable a callback.
+ *
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] callback  callback function pointer or @p NULL
+ *
+ * @notapi
+ */
+void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback) {
+
+  if (callback != NULL) {
+    rtcp->rtc_cb = callback;
+    NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY));
+
+    /* Interrupts are enabled only after setting up the callback, this
+       way there is no need to check for the NULL callback pointer inside
+       the IRQ handler.*/
+    RTC->CRL &= ~(RTC_CRL_OWF | RTC_CRL_ALRF | RTC_CRL_SECF);
+    RTC->CRH |= RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE;
+  }
+  else {
+    NVICDisableVector(RTC_IRQn);
+    RTC->CRL = 0;
+    RTC->CRH = 0;
+  }
+}
 
 #endif /* HAL_USE_RTC */
 
diff --git a/os/hal/platforms/STM32/RTCv1/rtc_lld.h b/os/hal/platforms/STM32/RTCv1/rtc_lld.h
index f8256ae31..e3ce0e365 100644
--- a/os/hal/platforms/STM32/RTCv1/rtc_lld.h
+++ b/os/hal/platforms/STM32/RTCv1/rtc_lld.h
@@ -35,17 +35,19 @@
 /* Driver constants.                                                         */
 /*===========================================================================*/
 
+/**
+ * @brief   This RTC implementation supports callbacks.
+ */
+#define RTC_SUPPORTS_CALLBACKS      TRUE
+
+/**
+ * @brief   One alarm comparator available.
+ */
+#define RTC_ALARMS                  1
+
 /*===========================================================================*/
 /* Driver pre-compile time settings.                                         */
 /*===========================================================================*/
-/**
- * @brief   Switch to TRUE if you need callbacks from RTC. Switch to FALSE
- *          if you need only time keeping.
- * @note    Default is true.
- */
-#if !defined(RTC_SUPPORTS_CALLBACKS) || defined(__DOXYGEN__)
-#define RTC_SUPPORTS_CALLBACKS              TRUE
-#endif
 
 /*===========================================================================*/
 /* Derived constants and error checks.                                       */
@@ -55,46 +57,71 @@
 #error "RTC not present in the selected device"
 #endif
 
+#if !(STM32_RTC == STM32_RTC_LSE) && !(STM32_RTC == STM32_RTC_LSI) &&       \
+    !(STM32_RTC == STM32_RTC_HSE)
+#error "invalid source selected for RTC clock"
+#endif
+
 /*===========================================================================*/
 /* Driver data structures and types.                                         */
 /*===========================================================================*/
 
 /**
- * @brief Structure representing an RTC time value.
+ * @brief   Type of a structure representing an RTC alarm stamp.
  */
-typedef struct {
+typedef struct RTCAlarm RTCAlarm;
+
+/**
+ * @brief   Type of an RTC alarm.
+ */
+typedef uint32_t rtcalarm_t;
+
+/**
+ * @brief   Type of an RTC event.
+ */
+typedef enum {
+  RTC_EVENT_SECOND = 0,                 /** Triggered every second.         */
+  RTC_EVENT_ALARM = 1,                  /** Triggered on alarm.             */
+  RTC_EVENT_OVERFLOW = 2                /** Triggered on counter overflow.  */
+} rtcevent_t;
+
+/**
+ * @brief   Type of a generic RTC callback.
+ */
+typedef void (*rtccb_t)(RTCDriver *rtcp, rtcevent_t event);
+
+/**
+ * @brief   Structure representing an RTC time stamp.
+ */
+struct RTCTime {
   /**
-   * @brief Seconds sins UNIX epoch.
+   * @brief Seconds since UNIX epoch.
    */
   uint32_t tv_sec;
   /**
    * @brief Fractional part.
    */
   uint32_t tv_msec;
-}RTCDateTime;
-
+};
 
 /**
- * @brief Structure representing an RTC driver.
- * @note  This driver is dummy when callbacks disabled.
+ * @brief   Structure representing an RTC alarm specification.
+ */
+struct RTCAlarm {
+  /**
+   * @brief Seconds since UNIX epoch.
+   */
+  uint32_t tv_sec;
+};
+
+/**
+ * @brief   Structure representing an RTC driver.
  */
 struct RTCDriver{
-#if RTC_SUPPORTS_CALLBACKS
   /**
-   * @brief Overflow callback. Set it to NULL if not used.
+   * @brief Callback pointer.
    */
-  rtccb_t           overflow_cb;
-
-  /**
-   * @brief Every second callback. Set it to NULL if not used.
-   */
-  rtccb_t           second_cb;
-
-  /**
-   * @brief Alarm callback. Set it to NULL if not used.
-   */
-  rtccb_t           alarm_cb;
-#endif /* RTC_SUPPORTS_CALLBACKS */
+  rtccb_t           rtc_cb;
 };
 
 /*===========================================================================*/
@@ -105,27 +132,29 @@ struct RTCDriver{
 /* External declarations.                                                    */
 /*===========================================================================*/
 
-extern RTCDriver RTCD;
-
+#if !defined(__DOXYGEN__)
+extern RTCDriver RTCD1;
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   void rtc_lld_init(void);
-  void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflow_cb,
-                            rtccb_t second_cb, rtccb_t alarm_cb);
-
-  void rtc_lld_set_time(RTCDateTime *timespec);
-  void rtc_lld_get_time(RTCDateTime *timespec);
-
-  void rtc_lld_get_alarm(RTCDateTime *timespec);
-  void rtc_lld_set_alarm(RTCDateTime *timespec);
+  void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec);
+  void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec);
+  void rtc_lld_set_alarm(RTCDriver *rtcp,
+                         rtcalarm_t alarm,
+                         const RTCAlarm *alarmspec);
+  void rtc_lld_get_alarm(RTCDriver *rtcp,
+                         rtcalarm_t alarm,
+                         RTCAlarm *alarmspec);
+  void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback);
 #ifdef __cplusplus
 }
 #endif
 
-
 #endif /* HAL_USE_RTC */
+
 #endif /* _RTC_LLD_H_ */
 
 /** @} */
diff --git a/os/hal/platforms/STM32F1xx/stm32_rcc.h b/os/hal/platforms/STM32F1xx/stm32_rcc.h
index 9ca1140e9..0f19f7b07 100644
--- a/os/hal/platforms/STM32F1xx/stm32_rcc.h
+++ b/os/hal/platforms/STM32F1xx/stm32_rcc.h
@@ -214,8 +214,8 @@
  *
  * @api
  */
-#define rccEnableBKPInterface(lp) \
-  rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp);
+#define rccEnableBKPInterface(lp)                                           \
+  rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp)
 
 /**
  * @brief   Disables BKP interface clock.
@@ -225,22 +225,22 @@
  *
  * @api
  */
-#define rccDisableBKPInterface(lp) \
-    rccDisableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp);
+#define rccDisableBKPInterface(lp)                                          \
+  rccDisableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp)
 
 /**
  * @brief   Resets the Backup Domain interface.
  *
  * @api
  */
-#define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST);
+#define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST)
 
 /**
  * @brief   Resets the entire Backup Domain.
  *
  * @api
  */
-#define rccResetBKP() (RCC->BDCR |= RCC_BDCR_BDRST);
+#define rccResetBKP() (RCC->BDCR |= RCC_BDCR_BDRST)
 /** @} */
 
 /**
diff --git a/os/hal/platforms/STM32L1xx/hal_lld.h b/os/hal/platforms/STM32L1xx/hal_lld.h
index cf07e8036..6efee2ca7 100644
--- a/os/hal/platforms/STM32L1xx/hal_lld.h
+++ b/os/hal/platforms/STM32L1xx/hal_lld.h
@@ -514,11 +514,11 @@
 #if (STM32_LSECLK < 1000) || (STM32_LSECLK > 1000000)
 #error "STM32_LSECLK outside acceptable range (1...1000KHz)"
 #endif
-#else /* !#if STM32_LSE_ENABLED */
+#else /* !STM32_LSE_ENABLED */
 #if STM_RTCCLK == STM32_LSECLK
 #error "required LSE clock is not enabled"
 #endif
-#endif /* !#if STM32_LSE_ENABLED */
+#endif /* !STM32_LSE_ENABLED */
 
 /* PLL related checks.*/
 #if STM32_USB_CLOCK_ENABLED ||                                              \
diff --git a/os/hal/src/rtc.c b/os/hal/src/rtc.c
index 24ccce84e..dda5a9c95 100644
--- a/os/hal/src/rtc.c
+++ b/os/hal/src/rtc.c
@@ -52,88 +52,107 @@
 /*===========================================================================*/
 
 /**
- * @brief   Enable access to registers and initialize RTC if BKP domain
- *          was previously reset.
+ * @brief   RTC Driver initialization.
  * @note    This function is implicitly invoked by @p halInit(), there is
  *          no need to explicitly initialize the driver.
  *
  * @init
  */
 void rtcInit(void) {
+
   rtc_lld_init();
 }
 
-#if RTC_SUPPORTS_CALLBACKS || defined(__DOXYGEN__)
-/**
- * @brief   Enables or disables callbacks.
- * @details This function enables or disables callbacks, use a @p NULL pointer
- *          in order to disable a callback.
- * @pre     To use this function you must set @p RTC_SUPPORTS_CALLBACKS
- *          to @p TRUE.
- *
- * @param[in] rtcp      pointer to RTC driver structure
- * @param[in] overflowcb overflow callback function
- * @param[in] secondcb  every second callback function
- * @param[in] alarmcb   alarm callback function
- */
-void rtcSetCallback(RTCDriver *rtcp, rtccb_t overflowcb,
-                    rtccb_t secondcb, rtccb_t alarmcb) {
-
-  chDbgCheck((rtcp != NULL), "rtcSetCallback");
-
-  rtc_lld_set_callback(rtcp, overflowcb, secondcb, alarmcb);
-}
-#endif /* RTC_SUPPORTS_CALLBACKS */
-
 /**
  * @brief   Set current time.
  *
- * @param[in] timespec  pointer to a @p RTCDateTime structure
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] timespec  pointer to a @p RTCTime structure
+ *
+ * @api
  */
-void rtcSetTime(RTCDateTime *timespec) {
+void rtcSetTime(RTCDriver *rtcp, const RTCTime *timespec) {
 
-  chDbgCheck((timespec != NULL), "rtcSetTime");
+  chDbgCheck((rtcp != NULL) && (timespec != NULL), "rtcSetTime");
 
-  rtc_lld_set_time(timespec);
+  rtc_lld_set_time(rtcp, timespec);
 }
 
 /**
  * @brief   Get current time.
  *
- * @param[in] timespec  pointer to a @p RTCDateTime structure
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[out] timespec pointer to a @p RTCTime structure
+ *
+ * @api
  */
-void rtcGetTime(RTCDateTime *timespec) {
+void rtcGetTime(RTCDriver *rtcp, RTCTime *timespec) {
 
-  chDbgCheck((timespec != NULL), "rtcGetTime");
-  rtc_lld_get_time(timespec);
+  chDbgCheck((rtcp != NULL) && (timespec != NULL), "rtcGetTime");
+
+  rtc_lld_get_time(rtcp, timespec);
 }
 
+#if (RTC_ALARMS > 0) || defined(__DOXYGEN__)
 /**
  * @brief   Set alarm time.
  *
- * @param[in] timespec  pointer to a @p RTCDateTime structure
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] alarm     alarm identifier
+ * @param[in] alarmspec pointer to a @p RTCAlarm structure or @p NULL
+ *
+ * @api
  */
-void rtcSetAlarm(RTCDateTime *timespec) {
+void rtcSetAlarm(RTCDriver *rtcp,
+                 rtcalarm_t alarm,
+                 const RTCAlarm *alarmspec) {
 
-  chDbgCheck((timespec != NULL), "rtcSetAlarm");
+  chDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS), "rtcSetAlarm");
 
-  rtc_lld_set_alarm(timespec);
+  rtc_lld_set_alarm(rtcp, alarm, alarmspec);
 }
 
 /**
  * @brief   Get current alarm.
+ * @note    If an alarm has not been set then the returned alarm specification
+ *          is not meaningful.
  *
- * @param[in] timespec  pointer to a @p RTCDateTime structure
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] alarm     alarm identifier
+ * @param[out] alarmspec pointer to a @p RTCAlarm structure
+ *
+ * @api
  */
-void rtcGetAlarm(RTCDateTime *timespec){
+void rtcGetAlarm(RTCDriver *rtcp,
+                 rtcalarm_t alarm,
+                 RTCAlarm *alarmspec) {
 
-  chDbgCheck((timespec != NULL), "rtcGetAlarm");
+  chDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS) && (alarmspec != NULL),
+             "rtcGetAlarm");
 
-  rtc_lld_get_alarm(timespec);
+  rtc_lld_get_alarm(rtcp, alarm, alarmspec);
 }
+#endif /* RTC_ALARMS > 0 */
+
+#if RTC_SUPPORTS_CALLBACKS || defined(__DOXYGEN__)
+/**
+ * @brief   Enables or disables RTC callbacks.
+ * @details This function enables or disables callbacks, use a @p NULL pointer
+ *          in order to disable a callback.
+ *
+ * @param[in] rtcp      pointer to RTC driver structure
+ * @param[in] callback  callback function pointer or @p NULL
+ *
+ * @api
+ */
+void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback) {
+
+  chDbgCheck((rtcp != NULL), "rtcSetCallback");
+
+  rtc_lld_set_callback(rtcp, callback);
+}
+#endif /* RTC_SUPPORTS_CALLBACKS */
 
 #endif /* HAL_USE_RTC */
 
 /** @} */
-
-
diff --git a/testhal/STM32F1xx/RTC/Makefile b/testhal/STM32F1xx/RTC/Makefile
index 2f471c293..7748841bd 100644
--- a/testhal/STM32F1xx/RTC/Makefile
+++ b/testhal/STM32F1xx/RTC/Makefile
@@ -12,7 +12,7 @@ ifeq ($(USE_OPT),)
 #	If all calls to a given function are integrated, and the function is declared static, then the function is normally not output as assembler code in its own right.
 #	Enabled at level '-O3'.
 
-  USE_OPT = -O0 -ggdb -fomit-frame-pointer -falign-functions=16
+  USE_OPT = -O2 -ggdb -fomit-frame-pointer -falign-functions=16
   #USE_OPT = -O1 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-inline
   #USE_OPT = -O2 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-strict-aliasing
   #USE_OPT = -O3 -ggdb -fomit-frame-pointer -falign-functions=16
@@ -86,7 +86,6 @@ CSRC = $(PORTSRC) \
        $(CHIBIOS)/os/various/evtimer.c \
        $(CHIBIOS)/os/various/syscalls.c \
        main.c \
-        
 
 # C++ sources that can be compiled in ARM or THUMB mode depending on the global
 # setting.
@@ -215,6 +214,3 @@ ifeq ($(USE_FWLIB),yes)
 endif
 
 include $(CHIBIOS)/os/ports/GCC/ARMCMx/rules.mk
-
-
-
diff --git a/testhal/STM32F1xx/RTC/main.c b/testhal/STM32F1xx/RTC/main.c
index 070ac50f2..ea7155f47 100644
--- a/testhal/STM32F1xx/RTC/main.c
+++ b/testhal/STM32F1xx/RTC/main.c
@@ -21,14 +21,11 @@
 #include "ch.h"
 #include "hal.h"
 
-
-RTCDateTime timespec;
-RTCDateTime alarmspec;
+RTCTime timespec;
+RTCAlarm alarmspec;
 
 #define TEST_ALARM_WAKEUP FALSE
 
-
-
 #if TEST_ALARM_WAKEUP
 
 /* sleep indicator thread */
@@ -64,38 +61,37 @@ int main(void) {
   return 0;
 }
 
-
-
 #else /* TEST_ALARM_WAKEUP */
 
-static void my_overflowcb(RTCDriver *rtcp){
-  (void)rtcp;
-  palTogglePad(IOPORT3, GPIOC_LED);
-}
+static void my_cb(RTCDriver *rtcp, rtcevent_t event) {
 
-static void my_secondcb(RTCDriver *rtcp){
   (void)rtcp;
-  //palTogglePad(IOPORT3, GPIOC_LED);
-}
 
-static void my_alarmcb(RTCDriver *rtcp){
-  (void)rtcp;
-  palTogglePad(IOPORT3, GPIOC_LED);
-  rtcGetTime(&timespec);
-  alarmspec.tv_sec = timespec.tv_sec + 10;
-  rtcSetAlarm(&alarmspec);
+  switch (event) {
+  case RTC_EVENT_OVERFLOW:
+    palTogglePad(GPIOC, GPIOC_LED);
+    break;
+  case RTC_EVENT_SECOND:
+    //palTogglePad(GPIOC, GPIOC_LED);
+    break;
+  case RTC_EVENT_ALARM:
+    palTogglePad(GPIOC, GPIOC_LED);
+    rtcGetTime(&RTCD1, &timespec);
+    alarmspec.tv_sec = timespec.tv_sec + 10;
+    rtcSetAlarm(&RTCD1, 0, &alarmspec);
+    break;
+  }
 }
 
-
 int main(void) {
   halInit();
   chSysInit();
 
-  rtcGetTime(&timespec);
+  rtcGetTime(&RTCD1, &timespec);
   alarmspec.tv_sec = timespec.tv_sec + 10;
-  rtcSetAlarm(&alarmspec);
+  rtcSetAlarm(&RTCD1, 0, &alarmspec);
 
-  rtcSetCallback(&RTCD, my_overflowcb, my_secondcb, my_alarmcb);
+  rtcSetCallback(&RTCD1, my_cb);
   while (TRUE){
     chThdSleepMilliseconds(500);
   }