Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 316 → Rev 317

/shark/trunk/kernel/modules/hartport.c
20,11 → 20,11
 
/**
------------
CVS : $Id: hartport.c,v 1.3 2002-11-11 08:32:06 pj Exp $
CVS : $Id: hartport.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2002-11-11 08:32:06 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
This file contains the Hartik 3.3.1 Port functions
175,16 → 175,17
static int getfreedes(void)
{
int p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
if (freeportdes == NIL) {
errno = EPORT_NO_MORE_DESCR;
kern_sti();
kern_frestore(f);
return -1;
}
p = freeportdes;
freeportdes = port_des[p].next;
kern_sti();
kern_frestore(f);
return(p);
}
 
193,10 → 194,12
/*----------------------------------------------------------------------*/
static void ungetdes(int pd)
{
kern_cli();
SYS_FLAGS f;
 
f = kern_fsave();
port_des[pd].next = freeportdes;
freeportdes = pd;
kern_sti();
kern_frestore(f);
}
 
/*----------------------------------------------------------------------*/
205,16 → 208,16
static int getfreeint(void)
{
int p;
 
kern_cli();
SYS_FLAGS f;
f = kern_fsave();
if (freeportint == NIL) {
errno = EPORT_NO_MORE_INTERF;
kern_sti();
kern_frestore(f);
return -1;
}
p = freeportint;
freeportint = port_int[p].next;
kern_sti();
kern_frestore(f);
return(p);
}
 
223,10 → 226,12
/*----------------------------------------------------------------------*/
static void ungetint(int pi)
{
kern_cli();
SYS_FLAGS f;
 
f = kern_fsave();
port_int[pi].next = freeportint;
freeportint = pi;
kern_sti();
kern_frestore(f);
}
 
/*----------------------------------------------------------------------*/
240,6 → 245,7
int i, pd, pi;
WORD letti = 0;
BYTE flag = FALSE;
SYS_FLAGS f;
 
/*
Prendo un descrittore di porta.
303,9 → 309,9
if (type == STICK) port_des[pd].dim_block = dim_mes;
else port_des[pd].dim_block = dim_mes * num_mes;
 
kern_cli();
f = kern_fsave();
port_des[pd].mem_block = kern_alloc(port_des[pd].dim_block);
kern_sti();
kern_frestore(f);
if (port_des[pd].mem_block == NULL) {
errno = EPORT_2_CONNECT;
sem_post(&hash_mutex);
496,6 → 502,7
int i;
struct port_ker *pd;
struct port_com *pp;
SYS_FLAGS f;
 
pp = &port_int[pi];
sem_wait(&hash_mutex);
506,9 → 513,9
sem_destroy(&pd->pieno);
sem_destroy(&pd->vuoto);
kern_cli();
f = kern_fsave();
kern_free(pd->mem_block, pd->dim_block);
kern_sti();
kern_frestore(f);
 
ungetdes(htable[i].port_index);
pp->valid = FALSE;
/shark/trunk/kernel/modules/nopm.c
20,11 → 20,11
 
/**
------------
CVS : $Id: nopm.c,v 1.3 2003-01-07 17:07:50 pj Exp $
CVS : $Id: nopm.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:50 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
See modules/nopm.h.
179,16 → 179,17
static int NOPM_destroy(RLEVEL l, mutex_t *m)
{
// NOPM_mutex_resource_des *lev = (NOPM_mutex_resource_des *)(resource_table[l]);
SYS_FLAGS f;
 
if ( ((NOPM_mutex_t *)m->opt)->owner != NIL)
return (EBUSY);
 
kern_cli();
f = kern_fsave();
if (m->opt) {
kern_free(m->opt,sizeof(NOPM_mutex_t));
m->opt = NULL;
}
kern_sti();
kern_frestore(f);
 
return 0;
}
196,8 → 197,9
static int NOPM_lock(RLEVEL l, mutex_t *m)
{
NOPM_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (NOPM_mutex_t *)m->opt;
if (!p) {
210,7 → 212,7
if (p->owner == exec_shadow) {
/* the task already owns the mutex */
p->counter++;
kern_sti();
kern_frestore(f);
return 0;
}
 
236,7 → 238,7
/* the mutex is free, We can lock it! */
p->owner = exec_shadow;
p->counter++;
kern_sti();
kern_frestore(f);
}
 
return 0;
245,8 → 247,9
static int NOPM_trylock(RLEVEL l, mutex_t *m)
{
NOPM_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (NOPM_mutex_t *)m->opt;
if (!p) {
258,7 → 261,7
 
if (p->owner != NIL) {
/* a task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EBUSY);
}
else {
265,7 → 268,7
/* the mutex is free, We can lock it! */
p->owner = exec_shadow;
p->counter++;
kern_sti();
kern_frestore(f);
}
 
return 0;
283,7 → 286,6
if (p->owner != exec_shadow) {
/* the mutex is owned by another task!!! */
kern_printf("wrongunlock<owner=%i,unlocker=%i>",p->owner,exec_shadow);
kern_sti();
return (EPERM);
}
 
290,7 → 292,6
p->counter--;
if (p->counter!=0) {
/* we have multiple lock on this mutex */
kern_sti();
return 0;
}
/shark/trunk/kernel/modules/npp.c
20,11 → 20,11
 
/**
------------
CVS : $Id: npp.c,v 1.2 2003-01-07 17:07:50 pj Exp $
CVS : $Id: npp.c,v 1.3 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:50 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
Non Preemptive Protocol. see npp.h for more details...
119,12 → 119,13
static int NPP_lock(RLEVEL l, mutex_t *m)
{
NPP_mutex_resource_des *lev;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
if (((PID)m->opt) == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
139,7 → 140,7
 
m->opt = (void *)exec_shadow;
 
kern_sti();
kern_frestore(f);
 
return 0;
}
/shark/trunk/kernel/modules/pc.c
20,11 → 20,11
 
/**
------------
CVS : $Id: pc.c,v 1.3 2003-09-12 10:10:41 giacomo Exp $
CVS : $Id: pc.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2003-09-12 10:10:41 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
Priority Ceiling protocol. see pc.h for more details...
236,16 → 236,17
static int PC_destroy(RLEVEL l, mutex_t *m)
{
// PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]);
SYS_FLAGS f;
 
if ( ((PC_mutex_t *)m->opt)->nblocked)
return (EBUSY);
 
kern_cli();
f = kern_fsave();
if (m->opt) {
kern_free(m->opt,sizeof(PC_mutex_t));
m->opt = NULL;
}
kern_sti();
kern_frestore(f);
 
return 0;
}
255,25 → 256,26
{
PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]);
PC_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (PC_mutex_t *)m->opt;
if (!p) {
/* if the mutex is not initialized, return an error! */
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
if (p->owner == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
if (p->ceiling > lev->priority[exec_shadow]) {
/* see POSIX standard p. 258 */
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
295,7 → 297,7
kern_context_load(proc_table[exec_shadow].context);
 
/* ... and reaquire the cli() before the test... */
kern_cli();
f = kern_fsave();
}
 
/* the mutex is free, We can lock it! */
306,7 → 308,7
 
PC_insert(lev, p);
 
kern_sti();
kern_frestore(f);
 
return 0;
}
315,31 → 317,32
{
PC_mutex_resource_des *lev = (PC_mutex_resource_des *)(resource_table[l]);
PC_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (PC_mutex_t *)m->opt;
if (!p) {
/* if the mutex is not initialized, return an error! */
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
if (p->owner == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
if (p->ceiling < lev->priority[exec_shadow]) {
/* see POSIX standard p. 258 */
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
while (!PC_accept(lev, lev->priority[exec_shadow])) {
/* a task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EBUSY);
}
 
351,7 → 354,7
 
PC_insert(lev, p);
 
kern_sti();
kern_frestore(f);
 
return 0;
}
368,7 → 371,6
 
if (p->owner != exec_shadow) {
/* the mutex is owned by another task!!! */
kern_sti();
return (EPERM);
}
 
/shark/trunk/kernel/modules/srp.c
20,11 → 20,11
 
/**
------------
CVS : $Id: srp.c,v 1.3 2003-01-07 17:07:51 pj Exp $
CVS : $Id: srp.c,v 1.4 2003-11-05 15:04:15 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:51 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:15 $
------------
 
Stack Resource Policy. see srp.h for general details...
525,6 → 525,7
{
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]);
SRP_mutex_t *mut;
SYS_FLAGS f;
 
mut = m->opt;
 
531,7 → 532,7
if (mut->owner != NIL)
return (EBUSY);
 
kern_cli();
f = kern_fsave();
 
/* the mutex isn't in the srpstack, because it is not busy */
 
546,7 → 547,7
kern_free(m->opt,sizeof(SRP_mutex_t));
m->opt = NULL;
}
kern_sti();
kern_frestore(f);
 
return 0;
}
556,19 → 557,20
SRP_mutex_resource_des *lev = (SRP_mutex_resource_des *)(resource_table[l]);
SRP_mutex_t *mut;
DWORD oldsysceiling;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
mut = (SRP_mutex_t *)m->opt;
if (!mut) {
/* if the mutex is not initialized */
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
if (mut->owner == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
581,7 → 583,7
// mut->use[exec_shadow],
// lev->proc_preempt[exec_shadow].preempt,exec_shadow);
kern_raise(XSRP_INVALID_LOCK, exec_shadow);
kern_sti();
kern_frestore(f);
return (EINVAL);
}
 
637,7 → 639,7
}
}
 
kern_sti();
kern_frestore(f);
 
return 0;
}
658,13 → 660,11
 
if (mut->owner != exec_shadow) {
/* the mutex is owned by another task!!! */
kern_sti();
return (EPERM);
}
 
if (!lev->srpstack || lev->srpstack != mut) {
/* the mutex is not the top of the stack!!! (erroneous nesting!) */
kern_sti();
return (EINVAL);
}
 
/shark/trunk/kernel/modules/pi.c
20,11 → 20,11
 
/**
------------
CVS : $Id: pi.c,v 1.2 2003-01-07 17:07:50 pj Exp $
CVS : $Id: pi.c,v 1.3 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.2 $
Last update: $Date: 2003-01-07 17:07:50 $
Revision: $Revision: 1.3 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
Priority Inhertitance protocol. see pi.h for more details...
139,16 → 139,17
static int PI_destroy(RLEVEL l, mutex_t *m)
{
// PI_mutex_resource_des *lev = (PI_mutex_resource_des *)(resource_table[l]);
 
SYS_FLAGS f;
if ( ((PI_mutex_t *)m->opt)->nblocked)
return (EBUSY);
 
kern_cli();
f = kern_fsave();
if (m->opt) {
kern_free(m->opt,sizeof(PI_mutex_t));
m->opt = NULL;
}
kern_sti();
kern_frestore(f);
 
return 0;
}
166,9 → 167,11
{
PI_mutex_resource_des *lev = (PI_mutex_resource_des *)(resource_table[l]);
PI_mutex_t *p;
SYS_FLAGS f;
// return 0;
kern_cli();
 
f = kern_fsave();
 
p = (PI_mutex_t *)m->opt;
if (!p) {
/* if the mutex is not initialized, initialize it! */
180,7 → 183,7
 
if (p->owner == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
196,7 → 199,7
kern_context_load(proc_table[exec_shadow].context);
 
/* ... and reaquire the cli() before the test... */
kern_cli();
kern_frestore(f);
}
 
/* the mutex is free, We can lock it! */
204,7 → 207,7
 
p->owner = exec_shadow;
 
kern_sti();
kern_frestore(f);
 
return 0;
}
212,8 → 215,9
static int PI_trylock(RLEVEL l, mutex_t *m)
{
PI_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (PI_mutex_t *)m->opt;
if (!p) {
225,7 → 229,7
 
if (p->owner != NIL) {
/* a task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EBUSY);
}
else {
235,7 → 239,7
 
p->owner = exec_shadow;
 
kern_sti();
kern_frestore(f);
return 0;
}
}
245,6 → 249,7
PI_mutex_resource_des *lev;
PI_mutex_t *p;
int i, j;
 
// return 0;
p = (PI_mutex_t *)m->opt;
if (!p)
252,7 → 257,6
 
if (p->owner != exec_shadow) {
/* the mutex is owned by another task!!! */
kern_sti();
return (EPERM);
}
 
/shark/trunk/kernel/modules/sem.c
20,11 → 20,11
 
/**
------------
CVS : $Id: sem.c,v 1.3 2003-01-07 17:07:51 pj Exp $
CVS : $Id: sem.c,v 1.4 2003-11-05 15:04:15 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:51 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:15 $
------------
 
This file contains the Hartik 3.3.1 Semaphore functions
151,10 → 151,12
// the pshared parameter is NRQ for PSE52
int sem_init(sem_t *sem, int pshared, unsigned int value)
{
SYS_FLAGS f;
if (value > SEM_VALUE_MAX)
return EINVAL;
 
kern_cli();
f = kern_fsave();
*sem = free_sem;
if (*sem != NIL) {
free_sem = sem_table[*sem].next;
165,10 → 167,10
}
else {
errno = ENOSPC;
kern_sti();
kern_frestore(f);
return -1;
}
kern_sti();
kern_frestore(f);
return 0;
}
 
177,17 → 179,19
/*----------------------------------------------------------------------*/
int sem_destroy(sem_t *sem)
{
kern_cli();
SYS_FLAGS f;
f = kern_fsave();
 
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) {
errno = EINVAL;
kern_sti();
kern_frestore(f);
return -1;
}
 
if (sem_table[*sem].blocked.first != NIL) {
errno = EBUSY;
kern_sti();
kern_frestore(f);
return -1;
}
 
195,7 → 199,7
sem_table[*sem].next = free_sem;
free_sem = *sem;
 
kern_sti();
kern_frestore(f);
return 0;
}
 
210,8 → 214,9
int found = 0;
mode_t m;
sem_t sem;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
for (i = 0; i < SEM_NSEMS_MAX; i++)
if (sem_table[i].used) {
223,16 → 228,16
if (found) {
if (oflag == (O_CREAT | O_EXCL)) {
errno = EEXIST;
kern_sti();
kern_frestore(f);
return SEM_FAILED;
} else {
kern_sti();
kern_frestore(f);
return &sem_table[i].index;
}
} else {
if (!(oflag & O_CREAT)) {
errno = ENOENT;
kern_sti();
kern_frestore(f);
return SEM_FAILED;
} else {
va_list l;
244,7 → 249,7
 
if (j > SEM_VALUE_MAX) {
errno = EINVAL;
kern_sti();
kern_frestore(f);
return SEM_FAILED;
}
 
256,12 → 261,12
sem_table[sem].count = j;
iq_init(&sem_table[sem].blocked, &freedesc, 0);
sem_table[sem].used = 1;
kern_sti();
kern_frestore(f);
return &sem_table[sem].index;
}
else {
errno = ENOSPC;
kern_sti();
kern_frestore(f);
return SEM_FAILED;
}
}
273,11 → 278,13
/*----------------------------------------------------------------------*/
int sem_close(sem_t *sem)
{
kern_cli();
SYS_FLAGS f;
 
f = kern_fsave();
 
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) {
errno = EINVAL;
kern_sti();
kern_frestore(f);
return -1;
}
 
293,7 → 300,7
sem_table[*sem].next = free_sem;
free_sem = *sem;
 
kern_sti();
kern_frestore(f);
return 0;
}
 
304,8 → 311,9
{
int i;
int found = 0;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
for (i = 0; i < SEM_NSEMS_MAX; i++)
if (sem_table[i].used) {
319,11 → 327,11
sem_table[i].used = 0;
sem_table[i].next = free_sem;
free_sem = i;
kern_sti();
kern_frestore(f);
return 0;
} else {
errno = ENOENT;
kern_sti();
kern_frestore(f);
return SEM_FAILED;
}
}
393,6 → 401,7
int sem_trywait(sem_t *s)
{
struct sem_des *s1; /* It speeds up access */
SYS_FLAGS f;
 
if (*s < 0 || *s >= SEM_NSEMS_MAX || !sem_table[*s].used) {
errno = EINVAL;
399,7 → 408,7
return -1;
}
 
kern_cli();
f = kern_fsave();
 
s1 = &sem_table[*s];
 
408,13 → 417,13
 
if (s1->blocked.first != NIL || s1->count == 0) {
errno = EAGAIN;
kern_sti();
kern_frestore(f);
return -1;
}
else
s1->count--;
kern_sti();
kern_frestore(f);
return 0;
}
 
426,6 → 435,10
int sem_xwait(sem_t *s, int n, int wait)
{
struct sem_des *s1; /* It speeds up access */
SYS_FLAGS f;
f = kern_fsave();
kern_frestore(f);
 
if (*s < 0 || *s >= SEM_NSEMS_MAX || !sem_table[*s].used) {
errno = EINVAL;
434,7 → 447,7
 
/* We do not need to save context if we are sure we shall not block! */
if (wait == NON_BLOCK)
kern_cli();
f = kern_fsave();
else
proc_table[exec_shadow].context = kern_context_save();
 
448,13 → 461,13
 
if (s1->blocked.first != NIL || s1->count < n) {
errno = EAGAIN;
kern_sti();
kern_frestore(f);
return -1;
}
else
s1->count -= n;
 
kern_sti();
kern_frestore(f);
return 0;
}
/* The blocking wait is more complex... */
665,6 → 678,7
int sem_getvalue(sem_t *sem, int *sval)
{
PID p;
SYS_FLAGS f;
 
if (*sem < 0 || *sem >= SEM_NSEMS_MAX || !sem_table[*sem].used) {
errno = EINVAL;
671,7 → 685,7
return -1;
}
 
kern_cli();
f = kern_fsave();
 
if (iq_isempty(&sem_table[*sem].blocked))
/* the sem is free */
686,7 → 700,7
} while (p != NIL);
}
 
kern_sti();
kern_frestore(f);
return 0;
}
 
/shark/trunk/kernel/modules/nop.c
20,11 → 20,11
 
/**
------------
CVS : $Id: nop.c,v 1.3 2003-01-07 17:07:50 pj Exp $
CVS : $Id: nop.c,v 1.4 2003-11-05 15:04:14 giacomo Exp $
 
File: $File$
Revision: $Revision: 1.3 $
Last update: $Date: 2003-01-07 17:07:50 $
Revision: $Revision: 1.4 $
Last update: $Date: 2003-11-05 15:04:14 $
------------
 
Binary Semaphores. see nop.h for more details...
116,16 → 116,17
static int NOP_destroy(RLEVEL l, mutex_t *m)
{
// NOP_mutex_resource_des *lev = (NOP_mutex_resource_des *)(resource_table[l]);
SYS_FLAGS f;
 
if ( ((NOP_mutex_t *)m->opt)->owner != NIL)
return (EBUSY);
 
kern_cli();
f = kern_fsave();
if (m->opt) {
kern_free(m->opt,sizeof(NOP_mutex_t));
m->opt = NULL;
}
kern_sti();
kern_frestore(f);
 
return 0;
}
133,8 → 134,9
static int NOP_lock(RLEVEL l, mutex_t *m)
{
NOP_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (NOP_mutex_t *)m->opt;
if (!p) {
146,7 → 148,7
 
if (p->owner == exec_shadow) {
/* the task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EDEADLK);
}
 
171,7 → 173,7
else {
/* the mutex is free, We can lock it! */
p->owner = exec_shadow;
kern_sti();
kern_frestore(f);
}
 
return 0;
180,8 → 182,9
static int NOP_trylock(RLEVEL l, mutex_t *m)
{
NOP_mutex_t *p;
SYS_FLAGS f;
 
kern_cli();
f = kern_fsave();
 
p = (NOP_mutex_t *)m->opt;
if (!p) {
193,13 → 196,13
 
if (p->owner != NIL) {
/* a task already owns the mutex */
kern_sti();
kern_frestore(f);
return (EBUSY);
}
else {
/* the mutex is free, We can lock it! */
p->owner = exec_shadow;
kern_sti();
kern_frestore(f);
}
 
return 0;
215,7 → 218,6
 
if (p->owner != exec_shadow) {
/* the mutex is owned by another task!!! */
kern_sti();
return (EPERM);
}
 
/shark/trunk/oslib/kl/advtimer.c
69,8 → 69,6
unsigned int start_8253, end_8253, delta_8253;
 
cli();
outp(0x61, (inp(0x61) & ~0x02) | 0x01);
 
outp(0x43,0xB0); /* binary, mode 0, LSB/MSB, Ch 2 */
124,8 → 122,6
message("Calibrated Clk_per_msec = %10d\n",clk_per_msec);
 
sti();
}
 
#define CMOS_INIT 0
142,8 → 138,6
 
unsigned char set;
 
cli();
 
CMOS_READ(0x0C,set);
 
barrier();
163,8 → 157,6
cmos_calibrate_status = CMOS_BEGIN;
}
sti();
 
}
 
//TSC Calibration using RTC
173,8 → 165,6
 
unsigned long long dtsc;
 
cli();
irq_bind(8, calibrate_tsc_IRQ8, INT_FORCE);
 
CMOS_READ(0x0A,save_CMOS_regA);
184,12 → 174,14
CMOS_WRITE(0x0B,0x42); // Enable Interrupt
 
irq_unmask(8);
 
sti();
 
while (cmos_calibrate_status != CMOS_END) {
barrier();
}
cli();
 
dtsc = irq8_end - irq8_start;
 
197,15 → 189,11
 
message("Calibrated CPU Clk/msec = %10d\n",clk_per_msec);
 
cli();
 
irq_mask(8);
 
CMOS_WRITE(0x0A,save_CMOS_regA);
CMOS_WRITE(0x0B,save_CMOS_regB);
 
sti();
 
}
 
int apic_get_maxlvt(void)
361,8 → 349,6
unsigned long long tsc_start = 0, tsc_end = 0, dtsc;
unsigned int tmp_value;
 
cli();
 
tmp_value = SET_APIC_TIMER_BASE(APIC_TIMER_BASE_DIV) | LOCAL_TIMER_VECTOR;
apic_write_around(APIC_LVTT, tmp_value);
 
391,8 → 377,6
 
disable_APIC_timer();
 
sti();
 
dtsc = tsc_end - tsc_start;
dapic = apic_start - apic_end;
 
445,7 → 429,7
#ifdef __APIC__
unsigned int msr_low_orig, tmp;
 
cli();
cli();
 
disable_APIC_timer();