src/arch/x86/rtc.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       rtc.cpp, version 1.1                               *
************************************************************
*                                                          *
*real time clock                                           *
*                                                          *
*03'05'04- forked from o.05 branch.s rtc.cpp(1.1)          *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/kmalloc.hpp"
#include "src/arch/x86/gdt.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/heap.hpp"
#include "src/ipc/lock.hpp"
#include "src/common/io.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/thread/scheduler.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/irq.hpp"
#include "src/arch/x86/rtc.hpp"

// /*how many ticks have passed since last we serviced the handlers*/
// uint32 volatile rtc_times = 0;
// /*this is a list of procedures to handle periodically*/
// rtc_list *rtc_procs = 0;
// /*the lock for the rtc handlers linked list*/

namespace Arch {
namespace x86 {
namespace RTC {


//variables
uint64 volatile up_time = 0;    /*this counter is incremented after each interrupt; *has to be volatile*/
uint32 rtc_id;                  /*here we keep the value necessary to uninstall the handler*/
blist_t rtc_funcs;
class IPC::Lock::lock_t rtc_lock("rtc");

//install the rtc handler
void init()
 {
        memset(&rtc_funcs, 0, sizeof(rtc_funcs));
        memset(&rtc_lock, 0, sizeof(rtc_lock));
/*install handler*/
        rtc_id = Arch::x86::Interr::kernel_pic.install_irq(DEF_RTC_IRQ, &rtc_handler, GDT::code_sel_kernel);
/*acknowledge the rtc, sometimes rtc doesn't work without this*/
        ack_rtc();
/*enable rtc*/
        enable_rtc();
 }

//uninstall the rtc handler
void done()
 {
/*uninstall the handler*/
//      del_chainHdl(DEF_RTC_IRQ, rtc_id);
        rtc_id = 0;

        disable_rtc();
// /*free all the list's memory*/
// rtc_list *item, *temp;
//      item = rtc_procs;
//      while (item)
//       {
//              temp = item -> next;
//              delete item;
//              item = temp;
//       }

 }

//enable rtc
void enable_rtc()
 {
/*to access status byte B*/
        IOPorts::outb(DEF_RTC_BASE, DEF_RTC_ST_B);
/*and enable periodic interrupts*/
        IOPorts::outb(DEF_RTC_BASE + 1, IOPorts::inb(DEF_RTC_BASE + 1) | DEF_RTC_PERIODIC);
 }

//disable rtc
void disable_rtc()
 {
/*to access status byte B*/
        IOPorts::outb(DEF_RTC_BASE, DEF_RTC_ST_B);
/*and enable periodic interrupts*/
        IOPorts::outb(DEF_RTC_BASE + 1, IOPorts::inb(DEF_RTC_BASE + 1) & DEF_RTC_NO_PERIODIC);
 }

/*acknowledge the rtc and return status byte c*/
uint8 ack_rtc()
 {
        IOPorts::outb(DEF_RTC_BASE, DEF_RTC_ST_C);
        return IOPorts::inb(DEF_RTC_BASE+1);
 }


rtc_handle add_proc(RTC_proc proc, uint32 ticks_def, bool one_shot, int arg1, int arg2)
 {
blist_s *obj;
rtc_list *item;
uint64 boom=up_time+ticks_def;
/* create the proc object */
        item=(rtc_list*) Memory::Heap::heap0.malloc(sizeof(rtc_list), 1, "rtc item", NULL);
        item->proc=proc;
        item->boom=boom;
        item->one_shot=one_shot;
        item->arg1=arg1;
        item->arg2=arg2;
        item->ticks_def=ticks_def;
/* create a blist_s */
        obj=(blist_s*) Memory::Heap::heap0.malloc(sizeof(blist_s), 1, "rtc blist_s", NULL);
        obj->size=sizeof(rtc_list);
        obj->data=item;
/* add to the list */
        return (rtc_handle) blistsort_link(&rtc_funcs, obj, &rtccompar);
 }

/* compar the time of two rtc events */
int rtccompar(const void *a, const void *b)
 {
uint64 A, B;
        A= bli_dt(a,rtc_list*)->boom;
        B= bli_dt(b,rtc_list*)->boom;
        if (A > B)
                return 1;
        if (A < B)
                return -1;
        return 0;
 }

//del a proc
int del_proc(blist_s *item) {
   rtc_lock.lock();
/* **** */
//unlink from tha list
        if (item->prev)
                item->prev->next=item->next;
        else
                rtc_funcs.head=item->next;              //this was "head"

        if (item->next)
                item->next->prev=item->prev;
        else
                rtc_funcs.tail=item->prev;              //this was "tail"
   rtc_lock.ulock();
   return 1;
}

int del_proc(rtc_handle handle)
 {
   return del_proc(reinterpret_cast<blist_s*>(handle));
 }

//the rtc handler
int rtc_handler(Interr::except2_t *code)
 {
//      cout("DIEEEE");
//      return 1;
// int x=0x1234565;
//      Memory::Pager::kmem.pte_lazy(0,2);
// int *i=NULL;
//      Memory::Pager::kmem.pte_map(0,3);
//      *i=0;
//      cout(x);
//if the lock is upon us, increase tha counter
static int halted=0;
/*get status byte c*/
        IOPorts::outb(DEF_RTC_BASE, DEF_RTC_ST_C);

/*check if the int was caused by periodic int; if yes, we can handle it*/
        if ((IOPorts::inb(DEF_RTC_BASE+1) & DEF_RTC_PERIOD_INT) == 0)
                return EINVAL;

        up_time++; halted++;
	::Thread::wake_threads();      //wake threads
//locked ? then pass
        if (rtc_lock.locked() == true)
                return ESUCCESS;

/*service the procs list*/
blist_s *item,*nxt;
rtc_list *li;
int n;
        rtc_lock.lock();
        for (n=0; n<halted;n++) //not to loose execution on locks
//      for (struct blist_s *item=rtc_funcs.head;item;item=nxt)
   item = rtc_funcs.head;
   while (item)
         {
                nxt=item->next;
                li=(rtc_list*)item->data;
                if (li->boom > (up_time - halted + n + 1))
                        break;
                li->proc(li->arg1, li->arg2);

                if (!li->one_shot) {
      //procedura uruchamiane stale
                        rtc_funcs.unlink(item);
                        li->boom=li->ticks_def+(up_time - halted + n + 1);
                rtc_lock.ulock();       //------------
                        blistsort_link(&rtc_funcs, item, &rtccompar);
                rtc_lock.lock();
                 } else {
       //procedura uruchamiana tylko raz
#if 1
//raczej hack, del_proc() nie moze zwalniac pamieci by to dzialalo
         del_proc(item);
#else
                        rtc_funcs.del(item);
#endif
       }
      item=nxt;
         }

        halted=0;
        rtc_lock.ulock();
        return ESUCCESS;
// 
// /*one more tick to be serviced, but sometimes the tick cannot be serviced,
// that's when a lock on rtc is put.*/
//      rtc_times++;
//      if (rtc_lock.is_locked())
//              return DEF_SUCCESS;
// 
// /*handlers*/
// uint32 i;
//      for (i=0; i<rtc_times;i++)
//              try_handlers();
// /*clear the counter*/
//      rtc_times=0;
// /*we've handled the periodic rtc interrupt*/
//      return DEF_SUCCESS;
//  }
// 
// /*runs all handlers supposed to run*/
// void try_handlers()
//  {
//      rtc_lock.lck();
// rtc_list *item, *next;
// /*servicing all the handlers*/
//      item = rtc_procs;
//      while (item)
//       {
//              next = item->next;
//      /*one less tick left to execution*/
//              item -> ticks--;
// 
//      /*no more ticks left before execution, run now*/
//              if (item -> ticks == 0)
//               {
//              /*push the argument and call handler*/
//                      asm volatile ("push %%edx" : : "d" (item->arg) );
//                      item -> proc();
//                      asm volatile ("add $4, %esp");
// 
//                      if (item->one_shot)
//                              del_rtc_proc((uint32)item);     /*if a one_shot, do not ever recall it*/
//                      else
//                              item -> ticks = item -> ticks_def;/*if not, refresh tick count*/
//               }
//      /*next element in list*/
//              item = next;
//       }
//      rtc_lock.ulock();
 }

//delay ticks 1024 Hz ticks
void tdelay(uint32 ticks)
 {
uint32 x;
uint32 fl;
        asm volatile ("pushf\npopl %0\nsti" : "=g" (fl) :);
        x = up_time + ticks;
        while (up_time < x) ;
        asm volatile ("pushl %0\npopf" : : "g" (fl));
 }


   };   /*namespace RTC*/
  };    /*namespace x86*/
 };     /*namespace Arch*/

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---