drivers/sgi/char/ds1286.c

   1 /*
   2  * DS1286 Real Time Clock interface for Linux
   3  *
   4  * Copyright (C) 1998, 1999, 2000 Ralf Baechle
   5  *
   6  * Based on code written by Paul Gortmaker.
   7  *
   8  * This driver allows use of the real time clock (built into nearly all
   9  * computers) from user space. It exports the /dev/rtc interface supporting
  10  * various ioctl() and also the /proc/rtc pseudo-file for status
  11  * information.
  12  *
  13  * The ioctls can be used to set the interrupt behaviour and generation rate
  14  * from the RTC via IRQ 8. Then the /dev/rtc interface can be used to make
  15  * use of these timer interrupts, be they interval or alarm based.
  16  *
  17  * The /dev/rtc interface will block on reads until an interrupt has been
  18  * received. If a RTC interrupt has already happened, it will output an
  19  * unsigned long and then block. The output value contains the interrupt
  20  * status in the low byte and the number of interrupts since the last read
  21  * in the remaining high bytes. The /dev/rtc interface can also be used with
  22  * the select(2) call.
  23  *
  24  * This program is free software; you can redistribute it and/or modify it
  25  * under the terms of the GNU General Public License as published by the
  26  * Free Software Foundation; either version 2 of the License, or (at your
  27  * option) any later version.
  28  */
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/miscdevice.h>
  32 #include <linux/slab.h>
  33 #include <linux/ioport.h>
  34 #include <linux/fcntl.h>
  35 #include <linux/init.h>
  36 #include <linux/poll.h>
  37 #include <linux/rtc.h>
  38 #include <linux/spinlock.h>
  39
  40 #include <asm/ds1286.h>
  41 #include <asm/io.h>
  42 #include <asm/uaccess.h>
  43 #include <asm/system.h>
  44
  45 #define DS1286_VERSION          "1.0"
  46
  47 /*
  48  *      We sponge a minor off of the misc major. No need slurping
  49  *      up another valuable major dev number for this. If you add
  50  *      an ioctl, make sure you don't conflict with SPARC's RTC
  51  *      ioctls.
  52  */
  53
  54 static DECLARE_WAIT_QUEUE_HEAD(ds1286_wait);
  55
  56 static ssize_t ds1286_read(struct file *file, char *buf,
  57                         size_t count, loff_t *ppos);
  58
  59 static int ds1286_ioctl(struct inode *inode, struct file *file,
  60                         unsigned int cmd, unsigned long arg);
  61
  62 static unsigned int ds1286_poll(struct file *file, poll_table *wait);
  63
  64 void ds1286_get_alm_time (struct rtc_time *alm_tm);
  65 void ds1286_get_time(struct rtc_time *rtc_tm);
  66 int ds1286_set_time(struct rtc_time *rtc_tm);
  67
  68 void set_rtc_irq_bit(unsigned char bit);
  69 void clear_rtc_irq_bit(unsigned char bit);
  70
  71 static inline unsigned char ds1286_is_updating(void);
  72
  73 static spinlock_t ds1286_lock = SPIN_LOCK_UNLOCKED;
  74
  75 /*
  76  *      Bits in rtc_status. (7 bits of room for future expansion)
  77  */
  78
  79 #define RTC_IS_OPEN             0x01    /* means /dev/rtc is in use     */
  80 #define RTC_TIMER_ON            0x02    /* missed irq timer active      */
  81
  82 unsigned char ds1286_status;            /* bitmapped status byte.       */
  83 unsigned long ds1286_freq;              /* Current periodic IRQ rate    */
  84
  85 unsigned char days_in_mo[] =
  86 {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  87
  88 /*
  89  *      Now all the various file operations that we export.
  90  */
  91
  92 static ssize_t ds1286_read(struct file *file, char *buf,
  93                            size_t count, loff_t *ppos)
  94 {
  95         return -EIO;
  96 }
  97
  98 static int ds1286_ioctl(struct inode *inode, struct file *file,
  99                         unsigned int cmd, unsigned long arg)
 100 {
 101
 102         struct rtc_time wtime;
 103
 104         switch (cmd) {
 105         case RTC_AIE_OFF:       /* Mask alarm int. enab. bit    */
 106         {
 107                 unsigned int flags;
 108                 unsigned char val;
 109
 110                 if (!capable(CAP_SYS_TIME))
 111                         return -EACCES;
 112
 113                 spin_lock_irqsave(&ds1286_lock, flags);
 114                 val = CMOS_READ(RTC_CMD);
 115                 val |=  RTC_TDM;
 116                 CMOS_WRITE(val, RTC_CMD);
 117                 spin_unlock_irqrestore(&ds1286_lock, flags);
 118
 119                 return 0;
 120         }
 121         case RTC_AIE_ON:        /* Allow alarm interrupts.      */
 122         {
 123                 unsigned int flags;
 124                 unsigned char val;
 125
 126                 if (!capable(CAP_SYS_TIME))
 127                         return -EACCES;
 128
 129                 spin_lock_irqsave(&ds1286_lock, flags);
 130                 val = CMOS_READ(RTC_CMD);
 131                 val &=  ~RTC_TDM;
 132                 CMOS_WRITE(val, RTC_CMD);
 133                 spin_unlock_irqrestore(&ds1286_lock, flags);
 134
 135                 return 0;
 136         }
 137         case RTC_WIE_OFF:       /* Mask watchdog int. enab. bit */
 138         {
 139                 unsigned int flags;
 140                 unsigned char val;
 141
 142                 if (!capable(CAP_SYS_TIME))
 143                         return -EACCES;
 144
 145                 spin_lock_irqsave(&ds1286_lock, flags);
 146                 val = CMOS_READ(RTC_CMD);
 147                 val |= RTC_WAM;
 148                 CMOS_WRITE(val, RTC_CMD);
 149                 spin_unlock_irqrestore(&ds1286_lock, flags);
 150
 151                 return 0;
 152         }
 153         case RTC_WIE_ON:        /* Allow watchdog interrupts.   */
 154         {
 155                 unsigned int flags;
 156                 unsigned char val;
 157
 158                 if (!capable(CAP_SYS_TIME))
 159                         return -EACCES;
 160
 161                 spin_lock_irqsave(&ds1286_lock, flags);
 162                 val = CMOS_READ(RTC_CMD);
 163                 val &= ~RTC_WAM;
 164                 CMOS_WRITE(val, RTC_CMD);
 165                 spin_unlock_irqrestore(&ds1286_lock, flags);
 166
 167                 return 0;
 168         }
 169         case RTC_ALM_READ:      /* Read the present alarm time */
 170         {
 171                 /*
 172                  * This returns a struct rtc_time. Reading >= 0xc0
 173                  * means "don't care" or "match all". Only the tm_hour,
 174                  * tm_min, and tm_sec values are filled in.
 175                  */
 176
 177                 ds1286_get_alm_time(&wtime);
 178                 break;
 179         }
 180         case RTC_ALM_SET:       /* Store a time into the alarm */
 181         {
 182                 /*
 183                  * This expects a struct rtc_time. Writing 0xff means
 184                  * "don't care" or "match all". Only the tm_hour,
 185                  * tm_min and tm_sec are used.
 186                  */
 187                 unsigned char hrs, min, sec;
 188                 struct rtc_time alm_tm;
 189
 190                 if (!capable(CAP_SYS_TIME))
 191                         return -EACCES;
 192
 193                 if (copy_from_user(&alm_tm, (struct rtc_time*)arg,
 194                                    sizeof(struct rtc_time)))
 195                         return -EFAULT;
 196
 197                 hrs = alm_tm.tm_hour;
 198                 min = alm_tm.tm_min;
 199
 200                 if (hrs >= 24)
 201                         hrs = 0xff;
 202
 203                 if (min >= 60)
 204                         min = 0xff;
 205
 206                 BIN_TO_BCD(sec);
 207                 BIN_TO_BCD(min);
 208                 BIN_TO_BCD(hrs);
 209
 210                 spin_lock(&ds1286_lock);
 211                 CMOS_WRITE(hrs, RTC_HOURS_ALARM);
 212                 CMOS_WRITE(min, RTC_MINUTES_ALARM);
 213                 spin_unlock(&ds1286_lock);
 214
 215                 return 0;
 216         }
 217         case RTC_RD_TIME:       /* Read the time/date from RTC  */
 218         {
 219                 ds1286_get_time(&wtime);
 220                 break;
 221         }
 222         case RTC_SET_TIME:      /* Set the RTC */
 223         {
 224                 struct rtc_time rtc_tm;
 225
 226                 if (!capable(CAP_SYS_TIME))
 227                         return -EACCES;
 228
 229                 if (copy_from_user(&rtc_tm, (struct rtc_time*)arg,
 230                                    sizeof(struct rtc_time)))
 231                         return -EFAULT;
 232
 233                 return ds1286_set_time(&rtc_tm);
 234         }
 235         default:
 236                 return -EINVAL;
 237         }
 238         return copy_to_user((void *)arg, &wtime, sizeof wtime) ? -EFAULT : 0;
 239 }
 240
 241 /*
 242  *      We enforce only one user at a time here with the open/close.
 243  *      Also clear the previous interrupt data on an open, and clean
 244  *      up things on a close.
 245  */
 246
 247 static int ds1286_open(struct inode *inode, struct file *file)
 248 {
 249         spin_lock_irq(&ds1286_lock);
 250
 251         if (ds1286_status & RTC_IS_OPEN)
 252                 goto out_busy;
 253
 254         ds1286_status |= RTC_IS_OPEN;
 255
 256         spin_lock_irq(&ds1286_lock);
 257         return 0;
 258
 259 out_busy:
 260         spin_lock_irq(&ds1286_lock);
 261         return -EBUSY;
 262 }
 263
 264 static int ds1286_release(struct inode *inode, struct file *file)
 265 {
 266         ds1286_status &= ~RTC_IS_OPEN;
 267
 268         return 0;
 269 }
 270
 271 static unsigned int ds1286_poll(struct file *file, poll_table *wait)
 272 {
 273         poll_wait(file, &ds1286_wait, wait);
 274
 275         return 0;
 276 }
 277
 278 /*
 279  *      The various file operations we support.
 280  */
 281
 282 static struct file_operations ds1286_fops = {
 283         llseek:         no_llseek,
 284         read:           ds1286_read,
 285         poll:           ds1286_poll,
 286         ioctl:          ds1286_ioctl,
 287         open:           ds1286_open,
 288         release:        ds1286_release,
 289 };
 290
 291 static struct miscdevice ds1286_dev=
 292 {
 293         RTC_MINOR,
 294         "rtc",
 295         &ds1286_fops
 296 };
 297
 298 int __init ds1286_init(void)
 299 {
 300         printk(KERN_INFO "DS1286 Real Time Clock Driver v%s\n", DS1286_VERSION);
 301         misc_register(&ds1286_dev);
 302
 303         return 0;
 304 }
 305
 306 static char *days[] = {
 307         "***", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
 308 };
 309
 310 /*
 311  *      Info exported via "/proc/rtc".
 312  */
 313 int get_ds1286_status(char *buf)
 314 {
 315         char *p, *s;
 316         struct rtc_time tm;
 317         unsigned char hundredth, month, cmd, amode;
 318
 319         p = buf;
 320
 321         ds1286_get_time(&tm);
 322         hundredth = CMOS_READ(RTC_HUNDREDTH_SECOND);
 323         BCD_TO_BIN(hundredth);
 324
 325         p += sprintf(p,
 326                      "rtc_time\t: %02d:%02d:%02d.%02d\n"
 327                      "rtc_date\t: %04d-%02d-%02d\n",
 328                      tm.tm_hour, tm.tm_min, tm.tm_sec, hundredth,
 329                      tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 330
 331         /*
 332          * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
 333          * match any value for that particular field. Values that are
 334          * greater than a valid time, but less than 0xc0 shouldn't appear.
 335          */
 336         ds1286_get_alm_time(&tm);
 337         p += sprintf(p, "alarm\t\t: %s ", days[tm.tm_wday]);
 338         if (tm.tm_hour <= 24)
 339                 p += sprintf(p, "%02d:", tm.tm_hour);
 340         else
 341                 p += sprintf(p, "**:");
 342
 343         if (tm.tm_min <= 59)
 344                 p += sprintf(p, "%02d\n", tm.tm_min);
 345         else
 346                 p += sprintf(p, "**\n");
 347
 348         month = CMOS_READ(RTC_MONTH);
 349         p += sprintf(p,
 350                      "oscillator\t: %s\n"
 351                      "square_wave\t: %s\n",
 352                      (month & RTC_EOSC) ? "disabled" : "enabled",
 353                      (month & RTC_ESQW) ? "disabled" : "enabled");
 354
 355         amode = ((CMOS_READ(RTC_MINUTES_ALARM) & 0x80) >> 5) |
 356                 ((CMOS_READ(RTC_HOURS_ALARM) & 0x80) >> 6) |
 357                 ((CMOS_READ(RTC_DAY_ALARM) & 0x80) >> 7);
 358         if (amode == 7)      s = "each minute";
 359         else if (amode == 3) s = "minutes match";
 360         else if (amode == 1) s = "hours and minutes match";
 361         else if (amode == 0) s = "days, hours and minutes match";
 362         else                 s = "invalid";
 363         p += sprintf(p, "alarm_mode\t: %s\n", s);
 364
 365         cmd = CMOS_READ(RTC_CMD);
 366         p += sprintf(p,
 367                      "alarm_enable\t: %s\n"
 368                      "wdog_alarm\t: %s\n"
 369                      "alarm_mask\t: %s\n"
 370                      "wdog_alarm_mask\t: %s\n"
 371                      "interrupt_mode\t: %s\n"
 372                      "INTB_mode\t: %s_active\n"
 373                      "interrupt_pins\t: %s\n",
 374                      (cmd & RTC_TDF) ? "yes" : "no",
 375                      (cmd & RTC_WAF) ? "yes" : "no",
 376                      (cmd & RTC_TDM) ? "disabled" : "enabled",
 377                      (cmd & RTC_WAM) ? "disabled" : "enabled",
 378                      (cmd & RTC_PU_LVL) ? "pulse" : "level",
 379                      (cmd & RTC_IBH_LO) ? "low" : "high",
 380                      (cmd & RTC_IPSW) ? "unswapped" : "swapped");
 381
 382         return  p - buf;
 383 }
 384
 385 /*
 386  * Returns true if a clock update is in progress
 387  */
 388 static inline unsigned char ds1286_is_updating(void)
 389 {
 390         return CMOS_READ(RTC_CMD) & RTC_TE;
 391 }
 392
 393
 394 void ds1286_get_time(struct rtc_time *rtc_tm)
 395 {
 396         unsigned char save_control;
 397         unsigned int flags;
 398         unsigned long uip_watchdog = jiffies;
 399
 400         /*
 401          * read RTC once any update in progress is done. The update
 402          * can take just over 2ms. We wait 10 to 20ms. There is no need to
 403          * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
 404          * If you need to know *exactly* when a second has started, enable
 405          * periodic update complete interrupts, (via ioctl) and then
 406          * immediately read /dev/rtc which will block until you get the IRQ.
 407          * Once the read clears, read the RTC time (again via ioctl). Easy.
 408          */
 409
 410         if (ds1286_is_updating() != 0)
 411                 while (jiffies - uip_watchdog < 2*HZ/100)
 412                         barrier();
 413
 414         /*
 415          * Only the values that we read from the RTC are set. We leave
 416          * tm_wday, tm_yday and tm_isdst untouched. Even though the
 417          * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
 418          * by the RTC when initially set to a non-zero value.
 419          */
 420         spin_lock_irqsave(&ds1286_lock, flags);
 421         save_control = CMOS_READ(RTC_CMD);
 422         CMOS_WRITE((save_control|RTC_TE), RTC_CMD);
 423
 424         rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
 425         rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
 426         rtc_tm->tm_hour = CMOS_READ(RTC_HOURS) & 0x1f;
 427         rtc_tm->tm_mday = CMOS_READ(RTC_DATE);
 428         rtc_tm->tm_mon = CMOS_READ(RTC_MONTH) & 0x1f;
 429         rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
 430
 431         CMOS_WRITE(save_control, RTC_CMD);
 432         spin_unlock_irqrestore(&ds1286_lock, flags);
 433
 434         BCD_TO_BIN(rtc_tm->tm_sec);
 435         BCD_TO_BIN(rtc_tm->tm_min);
 436         BCD_TO_BIN(rtc_tm->tm_hour);
 437         BCD_TO_BIN(rtc_tm->tm_mday);
 438         BCD_TO_BIN(rtc_tm->tm_mon);
 439         BCD_TO_BIN(rtc_tm->tm_year);
 440
 441         /*
 442          * Account for differences between how the RTC uses the values
 443          * and how they are defined in a struct rtc_time;
 444          */
 445         if (rtc_tm->tm_year < 45)
 446                 rtc_tm->tm_year += 30;
 447         if ((rtc_tm->tm_year += 40) < 70)
 448                 rtc_tm->tm_year += 100;
 449
 450         rtc_tm->tm_mon--;
 451 }
 452
 453 int ds1286_set_time(struct rtc_time *rtc_tm)
 454 {
 455         unsigned char mon, day, hrs, min, sec, leap_yr;
 456         unsigned char save_control;
 457         unsigned int yrs, flags;
 458
 459
 460         yrs = rtc_tm->tm_year + 1900;
 461         mon = rtc_tm->tm_mon + 1;   /* tm_mon starts at zero */
 462         day = rtc_tm->tm_mday;
 463         hrs = rtc_tm->tm_hour;
 464         min = rtc_tm->tm_min;
 465         sec = rtc_tm->tm_sec;
 466
 467         if (yrs < 1970)
 468                 return -EINVAL;
 469
 470         leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
 471
 472         if ((mon > 12) || (day == 0))
 473                 return -EINVAL;
 474
 475         if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
 476                 return -EINVAL;
 477
 478         if ((hrs >= 24) || (min >= 60) || (sec >= 60))
 479                 return -EINVAL;
 480
 481         if ((yrs -= 1940) > 255)    /* They are unsigned */
 482                 return -EINVAL;
 483
 484         if (yrs >= 100)
 485                 yrs -= 100;
 486
 487         BIN_TO_BCD(sec);
 488         BIN_TO_BCD(min);
 489         BIN_TO_BCD(hrs);
 490         BIN_TO_BCD(day);
 491         BIN_TO_BCD(mon);
 492         BIN_TO_BCD(yrs);
 493
 494         spin_lock_irqsave(&ds1286_lock, flags);
 495         save_control = CMOS_READ(RTC_CMD);
 496         CMOS_WRITE((save_control|RTC_TE), RTC_CMD);
 497
 498         CMOS_WRITE(yrs, RTC_YEAR);
 499         CMOS_WRITE(mon, RTC_MONTH);
 500         CMOS_WRITE(day, RTC_DATE);
 501         CMOS_WRITE(hrs, RTC_HOURS);
 502         CMOS_WRITE(min, RTC_MINUTES);
 503         CMOS_WRITE(sec, RTC_SECONDS);
 504         CMOS_WRITE(0, RTC_HUNDREDTH_SECOND);
 505
 506         CMOS_WRITE(save_control, RTC_CMD);
 507         spin_unlock_irqrestore(&ds1286_lock, flags);
 508
 509         return 0;
 510 }
 511
 512 void ds1286_get_alm_time(struct rtc_time *alm_tm)
 513 {
 514         unsigned char cmd;
 515         unsigned int flags;
 516
 517         /*
 518          * Only the values that we read from the RTC are set. That
 519          * means only tm_wday, tm_hour, tm_min.
 520          */
 521         spin_lock_irqsave(&ds1286_lock, flags);
 522         alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM) & 0x7f;
 523         alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM)  & 0x1f;
 524         alm_tm->tm_wday = CMOS_READ(RTC_DAY_ALARM)    & 0x07;
 525         cmd = CMOS_READ(RTC_CMD);
 526         spin_unlock_irqrestore(&ds1286_lock, flags);
 527
 528         BCD_TO_BIN(alm_tm->tm_min);
 529         BCD_TO_BIN(alm_tm->tm_hour);
 530         alm_tm->tm_sec = 0;
 531 }