/*
   * Copyright (C) 2014  René Kijewski  <rene.kijewski@fu-berlin.de>
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  
  /**
   * @ingroup     x86-irq
   * @{
   *
   * @file
   * @brief       Reading and interrupt handling for the Real Time Clock (RTC).
   *
   * @author      René Kijewski <rene.kijewski@fu-berlin.de>
   *
   * @}
   */
  
  #include "x86_pic.h"
  #include "x86_rtc.h"
  #include "irq.h"
  
  #include <stdio.h>
  
  
  #define ENABLE_DEBUG (0)
  #include "debug.h"
  
  static bool valid;
  
  static int32_t alarm_msg_content, periodic_msg_content, update_msg_content;
  static kernel_pid_t alarm_pid = KERNEL_PID_UNDEF, periodic_pid = KERNEL_PID_UNDEF, update_pid = KERNEL_PID_UNDEF;
  
  static void alarm_callback_default(uint8_t reg_c)
  {
      if (alarm_pid != KERNEL_PID_UNDEF) {
          msg_t m;
          m.type = reg_c | (RTC_REG_B_INT_ALARM << 8);
          m.content.value = alarm_msg_content;
          msg_send_int(&m, alarm_pid);
      }
  }
  
  static void periodic_callback_default(uint8_t reg_c)
  {
      if (periodic_pid != KERNEL_PID_UNDEF) {
          msg_t m;
          m.type = reg_c | (RTC_REG_B_INT_PERIODIC << 8);
          m.content.value = periodic_msg_content;
          msg_send_int(&m, periodic_pid);
      }
  }
  
  static void update_callback_default(uint8_t reg_c)
  {
      if (update_pid != KERNEL_PID_UNDEF) {
          msg_t m;
          m.type = reg_c | (RTC_REG_B_INT_UPDATE << 8);
          m.content.value = update_msg_content;
          msg_send_int(&m, update_pid);
      }
  }
  
  static x86_rtc_callback_t alarm_callback = alarm_callback_default;
  static x86_rtc_callback_t periodic_callback = periodic_callback_default;
  static x86_rtc_callback_t update_callback = update_callback_default;
  
  void x86_rtc_set_alarm_callback(x86_rtc_callback_t cb)
  {
      alarm_callback = cb ? cb : alarm_callback_default;
  }
  
  void x86_rtc_set_periodic_callback(x86_rtc_callback_t cb)
  {
      periodic_callback = cb ? cb : periodic_callback_default;
  }
  
  void x86_rtc_set_update_callback(x86_rtc_callback_t cb)
  {
      update_callback = cb ? cb : update_callback_default;
  }
  
  static void rtc_irq_handler(uint8_t irq_num)
  {
      (void) irq_num; /* == PIC_NUM_RTC */
  
      uint8_t c = x86_cmos_read(RTC_REG_C);
      DEBUG("RTC: c = 0x%02x, IRQ=%u, A=%u, P=%u, U=%u\n", c, (c & RTC_REG_C_IRQ) ? 1 : 0,
                                                              (c & RTC_REG_C_IRQ_ALARM) ? 1 : 0,
                                                              (c & RTC_REG_C_IRQ_PERIODIC) ? 1 : 0,
                                                              (c & RTC_REG_C_IRQ_UPDATE) ? 1 : 0);
      if (!(c & RTC_REG_C_IRQ)) {
          return;
      }
      if (c & RTC_REG_C_IRQ_ALARM) {
          alarm_callback(c);
      }
      if (c & RTC_REG_C_IRQ_PERIODIC) {
          periodic_callback(c);
      }
      if (c & RTC_REG_C_IRQ_UPDATE) {
          update_callback(c);
      }
  }
  
  void x86_init_rtc(void)
  {
      uint8_t d = x86_cmos_read(RTC_REG_D);
      valid = (d & RTC_REG_D_VALID) != 0;
      if (!valid) {
          puts("Warning: RTC does not work.");
          return;
      }
  
      x86_cmos_write(RTC_REG_B, x86_cmos_read(RTC_REG_B) & ~RTC_REG_B_INT_MASK);
      rtc_irq_handler(0);
      x86_pic_set_handler(PIC_NUM_RTC, &rtc_irq_handler);
      x86_pic_enable_irq(PIC_NUM_RTC);
  
      x86_rtc_data_t now;
      x86_rtc_read(&now);
      printf("RTC initialized [%02hhu:%02hhu:%02hhu, %04u-%02hhu-%02hhu]\n",
             now.hour, now.minute, now.second,
             now.century * 100 + now.year, now.month, now.day);
  
      if (x86_cmos_read(RTC_REG_POST) & (RTC_REG_POST_POWER_LOSS | RTC_REG_POST_TIME_INVALID)) {
          puts("Warning: RTC time is invalid (power loss?)");
      }
  }
  
  static inline bool is_update_in_progress(void)
  {
      return (x86_cmos_read(RTC_REG_A) & RTC_REG_A_UPDATING) != 0;
  }
  
  static uint8_t bcd2binary(uint8_t datum)
  {
      return (datum / 16) * 10 + (datum % 16);
  }
  
  static uint8_t binary2bcd(uint8_t datum)
  {
      return (datum / 10) * 16 + (datum % 10);
  }
  
  bool x86_rtc_read(x86_rtc_data_t *dest)
  {
      if (!valid) {
          return false;
      }
  
      unsigned old_status = irq_disable();
  
      while (is_update_in_progress()) {
          __asm__ volatile ("pause");
      }
  
      uint8_t b = x86_cmos_read(RTC_REG_B);
      do {
          dest->second  = x86_cmos_read(RTC_REG_SECOND);
          dest->minute  = x86_cmos_read(RTC_REG_MINUTE);
          dest->hour    = x86_cmos_read(RTC_REG_HOUR);
          dest->day     = x86_cmos_read(RTC_REG_DAY);
          dest->month   = x86_cmos_read(RTC_REG_MONTH);
          dest->year    = x86_cmos_read(RTC_REG_YEAR);
          dest->century = bcd2binary(x86_cmos_read(RTC_REG_CENTURY));
      } while (dest->second != x86_cmos_read(RTC_REG_SECOND));
      if (dest->century == 0) {
          dest->century = 20; // safe guess
      }
  
      if (!(b & RTC_REG_B_BIN)) {
          dest->second  = bcd2binary(dest->second);
          dest->minute  = bcd2binary(dest->minute);
          dest->hour    = ((dest->hour & 0x0F) + (((dest->hour & 0x70) / 16) * 10)) | (dest->hour & 0x80);
          dest->day     = bcd2binary(dest->day);
          dest->month   = bcd2binary(dest->month);
          dest->year    = bcd2binary(dest->year);
      }
      if (!(b & RTC_REG_B_24H) && (dest->hour & 0x80)) {
          dest->hour = ((dest->hour & 0x7F) + 12) % 24;
      }
  
      irq_restore(old_status);
      return true;
  }
  
  bool x86_rtc_set_alarm(const x86_rtc_data_t *when, uint32_t msg_content, kernel_pid_t target_pid, bool allow_replace)
  {
      if (!valid) {
          return false;
      }
  
      unsigned old_status = irq_disable();
      bool result;
      if (target_pid == KERNEL_PID_UNDEF) {
          result = true;
          alarm_pid = KERNEL_PID_UNDEF;
  
          uint8_t b = x86_cmos_read(RTC_REG_B);
          x86_cmos_write(RTC_REG_B, b & ~RTC_REG_B_INT_ALARM);
      }
      else {
          result = allow_replace || alarm_pid == KERNEL_PID_UNDEF;
          if (result) {
              alarm_msg_content = msg_content;
              alarm_pid = target_pid;
  
              uint8_t b = x86_cmos_read(RTC_REG_B);
              if (b & RTC_REG_B_BIN) {
                  x86_cmos_write(RTC_REG_ALARM_SECOND, when->second);
                  x86_cmos_write(RTC_REG_ALARM_MINUTE, when->minute);
                  x86_cmos_write(RTC_REG_ALARM_HOUR, when->hour);
              }
              else {
                  x86_cmos_write(RTC_REG_ALARM_SECOND, binary2bcd(when->second));
                  x86_cmos_write(RTC_REG_ALARM_MINUTE, binary2bcd(when->minute));
                  x86_cmos_write(RTC_REG_ALARM_HOUR, binary2bcd(when->hour));
              }
              x86_cmos_write(RTC_REG_B, b | RTC_REG_B_INT_ALARM);
          }
      }
      rtc_irq_handler(0);
      irq_restore(old_status);
      return result;
  }
  
  bool x86_rtc_set_periodic(uint8_t hz, uint32_t msg_content, kernel_pid_t target_pid, bool allow_replace)
  {
      if (!valid) {
          return false;
      }
  
      unsigned old_status = irq_disable();
      bool result;
      if (target_pid == KERNEL_PID_UNDEF || hz == RTC_REG_A_HZ_OFF) {
          result = true;
          periodic_pid = KERNEL_PID_UNDEF;
  
          uint8_t old_divider = x86_cmos_read(RTC_REG_A) & ~RTC_REG_A_HZ_MASK;
          x86_cmos_write(RTC_REG_A, old_divider | RTC_REG_A_HZ_OFF);
          x86_cmos_write(RTC_REG_B, x86_cmos_read(RTC_REG_B) & ~RTC_REG_B_INT_PERIODIC);
      }
      else {
          result = allow_replace || periodic_pid == KERNEL_PID_UNDEF;
          if (result) {
              periodic_msg_content = msg_content;
              periodic_pid = target_pid;
  
              uint8_t old_divider = x86_cmos_read(RTC_REG_A) & ~RTC_REG_A_HZ_MASK;
              x86_cmos_write(RTC_REG_A, old_divider | hz);
              x86_cmos_write(RTC_REG_B, x86_cmos_read(RTC_REG_B) | RTC_REG_B_INT_PERIODIC);
          }
      }
      rtc_irq_handler(0);
      irq_restore(old_status);
      return result;
  }
  
  bool x86_rtc_set_update(uint32_t msg_content, kernel_pid_t target_pid, bool allow_replace)
  {
      if (!valid) {
          return false;
      }
  
      unsigned old_status = irq_disable();
      bool result;
      if (target_pid == KERNEL_PID_UNDEF) {
          result = true;
          update_pid = KERNEL_PID_UNDEF;
  
          x86_cmos_write(RTC_REG_B, x86_cmos_read(RTC_REG_B) & ~RTC_REG_B_INT_UPDATE);
      }
      else {
          result = allow_replace || update_pid == KERNEL_PID_UNDEF;
          if (result) {
              update_msg_content = msg_content;
              update_pid = target_pid;
  
              x86_cmos_write(RTC_REG_B, x86_cmos_read(RTC_REG_B) | RTC_REG_B_INT_UPDATE);
          }
      }
      rtc_irq_handler(0);
      irq_restore(old_status);
      return result;
  }