minix/drivers/cmos/cmos.c

/* This file contains a device driver that can access the CMOS chip to 
 * get or set the system time. It drives the special file:
 *
 *     /dev/cmos	- CMOS chip
 *
 * Changes:
 *     Aug 04, 2005	Created. Read CMOS time.  (Jorrit N. Herder)
 *
 * Manufacturers usually use the ID value of the IBM model they emulate.
 * However some manufacturers, notably HP and COMPAQ, have had different
 * ideas in the past.
 *
 * Machine ID byte information source:
 *	_The Programmer's PC Sourcebook_ by Thom Hogan,
 *	published by Microsoft Press
 */

#include "../drivers.h"
#include <sys/ioc_cmos.h>
#include <time.h>
#include <ibm/cmos.h>
#include <ibm/bios.h>

extern int errno;			/* error number for PM calls */

FORWARD _PROTOTYPE( int gettime, (int who, int y2kflag, vir_bytes dst_time));
FORWARD _PROTOTYPE( void reply, (int reply, int replyee, int proc, int s));

FORWARD _PROTOTYPE( int read_register, (int register_address));
FORWARD _PROTOTYPE( int get_cmostime, (struct tm *tmp, int y2kflag));
FORWARD _PROTOTYPE( int dec_to_bcd, (int dec));
FORWARD _PROTOTYPE( int bcd_to_dec, (int bcd));

/*===========================================================================*
 *				   main 				     *
 *===========================================================================*/
PUBLIC void main(void)
{
  message m;
  int y2kflag;
  int result;
  int suspended = NONE;
  int s;

  while(TRUE) {

      /* Get work. */
      if (OK != (s=receive(ANY, &m)))
          panic("CMOS", "attempt to receive work failed", s);

      /* Handle request. */
      switch(m.m_type) {

      case DEV_OPEN:
      case DEV_CLOSE:
      case CANCEL:
          reply(TASK_REPLY, m.m_source, m.IO_ENDPT, OK);
          break;

      case DEV_PING:
	  notify(m.m_source);
	  break;
      case DEV_IOCTL:				

	  /* Probably best to SUSPEND the caller, CMOS I/O has nasty timeouts. 
	   * This way we don't block the rest of the system. First check if
           * another process is already suspended. We cannot handle multiple
           * requests at a time. 
           */
          if (suspended != NONE) {
              reply(TASK_REPLY, m.m_source, m.IO_ENDPT, EBUSY);
              break;
          }
          suspended = m.IO_ENDPT;
          reply(TASK_REPLY, m.m_source, m.IO_ENDPT, SUSPEND);

	  switch(m.REQUEST) {
	  case CIOCGETTIME:			/* get CMOS time */ 
          case CIOCGETTIMEY2K:
              y2kflag = (m.REQUEST = CIOCGETTIME) ? 0 : 1;
              result = gettime(m.IO_ENDPT, y2kflag, (vir_bytes) m.ADDRESS);
              break;
          case CIOCSETTIME:
          case CIOCSETTIMEY2K:
          default:				/* unsupported ioctl */
              result = ENOSYS;
          }

          /* Request completed. Tell the caller to check our status. */
	  notify(m.m_source);
          break;

      case DEV_STATUS:

          /* The FS calls back to get our status. Revive the suspended 
           * processes and return the status of reading the CMOS.
           */
	  if (suspended == NONE)
              reply(DEV_NO_STATUS, m.m_source, NONE, OK);
          else 
              reply(DEV_REVIVE, m.m_source, suspended, result);
          suspended = NONE;
          break;

      case SYN_ALARM:		/* shouldn't happen */
      case SYS_SIG:		/* ignore system events */
          continue;		

      default:
          reply(TASK_REPLY, m.m_source, m.IO_ENDPT, EINVAL);
      }	
  }
}

/*===========================================================================*
 *				reply					     *
 *===========================================================================*/
PRIVATE void reply(int code, int replyee, int process, int status)
{
  message m;
  int s;

  m.m_type = code;		/* TASK_REPLY or REVIVE */
  m.REP_STATUS = status;	/* result of device operation */
  m.REP_ENDPT = process;	/* which user made the request */
  if (OK != (s=send(replyee, &m)))
      panic("CMOS", "sending reply failed", s);
}

/*===========================================================================*
 *				gettime					     *
 *===========================================================================*/
PRIVATE int gettime(int who, int y2kflag, vir_bytes dst_time)
{
  unsigned char mach_id, cmos_state;
  struct tm time1;
  int i, s;

  /* First obtain the machine ID to see if we can read the CMOS clock. Only
   * for PS_386 and PC_AT this is possible. Otherwise, return an error.  
   */
  sys_vircopy(SELF, BIOS_SEG, (vir_bytes) MACHINE_ID_ADDR, 
  	SELF, D, (vir_bytes) &mach_id, MACHINE_ID_SIZE);
  if (mach_id != PS_386_MACHINE && mach_id != PC_AT_MACHINE) {
	printf("IS: Machine ID unknown. ID byte = %02x.\n", mach_id);
	return(EFAULT);
  }

  /* Now check the CMOS' state to see if we can read a proper time from it.
   * If the state is crappy, return an error.
   */
  cmos_state = read_register(CMOS_STATUS);
  if (cmos_state & (CS_LOST_POWER | CS_BAD_CHKSUM | CS_BAD_TIME)) {
	printf( "IS: CMOS RAM error(s) found. State = 0x%02x\n", cmos_state );
	if (cmos_state & CS_LOST_POWER)
	    printf("IS: RTC lost power. Reset CMOS RAM with SETUP." );
	if (cmos_state & CS_BAD_CHKSUM)
	    printf("IS: CMOS RAM checksum is bad. Run SETUP." );
	if (cmos_state & CS_BAD_TIME)
	    printf("IS: Time invalid in CMOS RAM. Reset clock." );
	return(EFAULT);
  }

  /* Everything seems to be OK. Read the CMOS real time clock and copy the
   * result back to the caller.
   */
  if (get_cmostime(&time1, y2kflag) != 0)
	return(EFAULT);
  sys_datacopy(SELF, (vir_bytes) &time1, 
  	who, dst_time, sizeof(struct tm));

  return(OK);
}

PRIVATE int get_cmostime(struct tm *t, int y2kflag)
{
/* Update the structure pointed to by time with the current time as read
 * from CMOS RAM of the RTC. If necessary, the time is converted into a
 * binary format before being stored in the structure.
 */
  int osec, n;
  unsigned long i;
  clock_t t0,t1;

  /* Start a timer to keep us from getting stuck on a dead clock. */
  getuptime(&t0);
  do {
	osec = -1;
	n = 0;
	do {
	        getuptime(&t1); 
		if (t1-t0 > 5*HZ) {
			printf("readclock: CMOS clock appears dead\n");
			return(1);
		}

		/* Clock update in progress? */
		if (read_register(RTC_REG_A) & RTC_A_UIP) continue;

		t->tm_sec = read_register(RTC_SEC);
		if (t->tm_sec != osec) {
			/* Seconds changed.  First from -1, then because the
			 * clock ticked, which is what we're waiting for to
			 * get a precise reading.
			 */
			osec = t->tm_sec;
			n++;
		}
	} while (n < 2);

	/* Read the other registers. */
	t->tm_min = read_register(RTC_MIN);
	t->tm_hour = read_register(RTC_HOUR);
	t->tm_mday = read_register(RTC_MDAY);
	t->tm_mon = read_register(RTC_MONTH);
	t->tm_year = read_register(RTC_YEAR);

	/* Time stable? */
  } while (read_register(RTC_SEC) != t->tm_sec
	|| read_register(RTC_MIN) != t->tm_min
	|| read_register(RTC_HOUR) != t->tm_hour
	|| read_register(RTC_MDAY) != t->tm_mday
	|| read_register(RTC_MONTH) != t->tm_mon
	|| read_register(RTC_YEAR) != t->tm_year);

  if ((read_register(RTC_REG_B) & RTC_B_DM_BCD) == 0) {
	/* Convert BCD to binary (default RTC mode). */
	t->tm_year = bcd_to_dec(t->tm_year);
	t->tm_mon = bcd_to_dec(t->tm_mon);
	t->tm_mday = bcd_to_dec(t->tm_mday);
	t->tm_hour = bcd_to_dec(t->tm_hour);
	t->tm_min = bcd_to_dec(t->tm_min);
	t->tm_sec = bcd_to_dec(t->tm_sec);
  }
  t->tm_mon--;	/* Counts from 0. */

  /* Correct the year, good until 2080. */
  if (t->tm_year < 80) t->tm_year += 100;

  if (y2kflag) {
	/* Clock with Y2K bug, interpret 1980 as 2000, good until 2020. */
	if (t->tm_year < 100) t->tm_year += 20;
  }
  return 0;
}

PRIVATE int read_register(int reg_addr)
{
/* Read a single CMOS register value. */
  unsigned long r;
  sys_outb(RTC_INDEX, reg_addr);
  sys_inb(RTC_IO, &r);
  return r;
}

PRIVATE int bcd_to_dec(int n)
{
  return ((n >> 4) & 0x0F) * 10 + (n & 0x0F);
}

PRIVATE int dec_to_bcd(int n)
{
  return ((n / 10) << 4) | (n % 10);
}