OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [rtc.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
2
 *      Real Time Clock interface for Linux
3
 *
4
 *      Copyright (C) 1996 Paul Gortmaker
5
 *
6
 *      This driver allows use of the real time clock (built into
7
 *      nearly all computers) from user space. It exports the /dev/rtc
8
 *      interface supporting various ioctl() and also the
9
 *      /proc/driver/rtc pseudo-file for status information.
10
 *
11
 *      The ioctls can be used to set the interrupt behaviour and
12
 *      generation rate from the RTC via IRQ 8. Then the /dev/rtc
13
 *      interface can be used to make use of these timer interrupts,
14
 *      be they interval or alarm based.
15
 *
16
 *      The /dev/rtc interface will block on reads until an interrupt
17
 *      has been received. If a RTC interrupt has already happened,
18
 *      it will output an unsigned long and then block. The output value
19
 *      contains the interrupt status in the low byte and the number of
20
 *      interrupts since the last read in the remaining high bytes. The
21
 *      /dev/rtc interface can also be used with the select(2) call.
22
 *
23
 *      This program is free software; you can redistribute it and/or
24
 *      modify it under the terms of the GNU General Public License
25
 *      as published by the Free Software Foundation; either version
26
 *      2 of the License, or (at your option) any later version.
27
 *
28
 *      Based on other minimal char device drivers, like Alan's
29
 *      watchdog, Ted's random, etc. etc.
30
 *
31
 *      1.07    Paul Gortmaker.
32
 *      1.08    Miquel van Smoorenburg: disallow certain things on the
33
 *              DEC Alpha as the CMOS clock is also used for other things.
34
 *      1.09    Nikita Schmidt: epoch support and some Alpha cleanup.
35
 *      1.09a   Pete Zaitcev: Sun SPARC
36
 *      1.09b   Jeff Garzik: Modularize, init cleanup
37
 *      1.09c   Jeff Garzik: SMP cleanup
38
 *      1.10    Paul Barton-Davis: add support for async I/O
39
 *      1.10a   Andrea Arcangeli: Alpha updates
40
 *      1.10b   Andrew Morton: SMP lock fix
41
 *      1.10c   Cesar Barros: SMP locking fixes and cleanup
42
 *      1.10d   Paul Gortmaker: delete paranoia check in rtc_exit
43
 *      1.10e   Maciej W. Rozycki: Handle DECstation's year weirdness.
44
 *      1.11    Takashi Iwai: Kernel access functions
45
 *                            rtc_register/rtc_unregister/rtc_control
46
 *      1.11a   Daniele Bellucci: Audit create_proc_read_entry in rtc_init
47
 *      1.12    Venkatesh Pallipadi: Hooks for emulating rtc on HPET base-timer
48
 *              CONFIG_HPET_EMULATE_RTC
49
 *      1.12a   Maciej W. Rozycki: Handle memory-mapped chips properly.
50
 *      1.12ac  Alan Cox: Allow read access to the day of week register
51
 */
52
 
53
#define RTC_VERSION             "1.12ac"
54
 
55
/*
56
 *      Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
57
 *      interrupts disabled. Due to the index-port/data-port (0x70/0x71)
58
 *      design of the RTC, we don't want two different things trying to
59
 *      get to it at once. (e.g. the periodic 11 min sync from time.c vs.
60
 *      this driver.)
61
 */
62
 
63
#include <linux/interrupt.h>
64
#include <linux/module.h>
65
#include <linux/kernel.h>
66
#include <linux/types.h>
67
#include <linux/miscdevice.h>
68
#include <linux/ioport.h>
69
#include <linux/fcntl.h>
70
#include <linux/mc146818rtc.h>
71
#include <linux/init.h>
72
#include <linux/poll.h>
73
#include <linux/proc_fs.h>
74
#include <linux/seq_file.h>
75
#include <linux/spinlock.h>
76
#include <linux/sysctl.h>
77
#include <linux/wait.h>
78
#include <linux/bcd.h>
79
#include <linux/delay.h>
80
 
81
#include <asm/current.h>
82
#include <asm/uaccess.h>
83
#include <asm/system.h>
84
 
85
#ifdef CONFIG_X86
86
#include <asm/hpet.h>
87
#endif
88
 
89
#ifdef CONFIG_SPARC32
90
#include <linux/pci.h>
91
#include <asm/ebus.h>
92
 
93
static unsigned long rtc_port;
94
static int rtc_irq = PCI_IRQ_NONE;
95
#endif
96
 
97
#ifdef  CONFIG_HPET_RTC_IRQ
98
#undef  RTC_IRQ
99
#endif
100
 
101
#ifdef RTC_IRQ
102
static int rtc_has_irq = 1;
103
#endif
104
 
105
#ifndef CONFIG_HPET_EMULATE_RTC
106
#define is_hpet_enabled()                       0
107
#define hpet_set_alarm_time(hrs, min, sec)      0
108
#define hpet_set_periodic_freq(arg)             0
109
#define hpet_mask_rtc_irq_bit(arg)              0
110
#define hpet_set_rtc_irq_bit(arg)               0
111
#define hpet_rtc_timer_init()                   do { } while (0)
112
#define hpet_rtc_dropped_irq()                  0
113
#ifdef RTC_IRQ
114
static irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
115
{
116
        return 0;
117
}
118
#endif
119
#else
120
extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
121
#endif
122
 
123
/*
124
 *      We sponge a minor off of the misc major. No need slurping
125
 *      up another valuable major dev number for this. If you add
126
 *      an ioctl, make sure you don't conflict with SPARC's RTC
127
 *      ioctls.
128
 */
129
 
130
static struct fasync_struct *rtc_async_queue;
131
 
132
static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
133
 
134
#ifdef RTC_IRQ
135
static void rtc_dropped_irq(unsigned long data);
136
 
137
static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq, 0, 0);
138
#endif
139
 
140
static ssize_t rtc_read(struct file *file, char __user *buf,
141
                        size_t count, loff_t *ppos);
142
 
143
static int rtc_ioctl(struct inode *inode, struct file *file,
144
                     unsigned int cmd, unsigned long arg);
145
 
146
#ifdef RTC_IRQ
147
static unsigned int rtc_poll(struct file *file, poll_table *wait);
148
#endif
149
 
150
static void get_rtc_alm_time (struct rtc_time *alm_tm);
151
#ifdef RTC_IRQ
152
static void set_rtc_irq_bit_locked(unsigned char bit);
153
static void mask_rtc_irq_bit_locked(unsigned char bit);
154
 
155
static inline void set_rtc_irq_bit(unsigned char bit)
156
{
157
        spin_lock_irq(&rtc_lock);
158
        set_rtc_irq_bit_locked(bit);
159
        spin_unlock_irq(&rtc_lock);
160
}
161
 
162
static void mask_rtc_irq_bit(unsigned char bit)
163
{
164
        spin_lock_irq(&rtc_lock);
165
        mask_rtc_irq_bit_locked(bit);
166
        spin_unlock_irq(&rtc_lock);
167
}
168
#endif
169
 
170
#ifdef CONFIG_PROC_FS
171
static int rtc_proc_open(struct inode *inode, struct file *file);
172
#endif
173
 
174
/*
175
 *      Bits in rtc_status. (6 bits of room for future expansion)
176
 */
177
 
178
#define RTC_IS_OPEN             0x01    /* means /dev/rtc is in use     */
179
#define RTC_TIMER_ON            0x02    /* missed irq timer active      */
180
 
181
/*
182
 * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
183
 * protected by the big kernel lock. However, ioctl can still disable the timer
184
 * in rtc_status and then with del_timer after the interrupt has read
185
 * rtc_status but before mod_timer is called, which would then reenable the
186
 * timer (but you would need to have an awful timing before you'd trip on it)
187
 */
188
static unsigned long rtc_status = 0;     /* bitmapped status byte.       */
189
static unsigned long rtc_freq = 0;       /* Current periodic IRQ rate    */
190
static unsigned long rtc_irq_data = 0;   /* our output to the world      */
191
static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
192
 
193
#ifdef RTC_IRQ
194
/*
195
 * rtc_task_lock nests inside rtc_lock.
196
 */
197
static DEFINE_SPINLOCK(rtc_task_lock);
198
static rtc_task_t *rtc_callback = NULL;
199
#endif
200
 
201
/*
202
 *      If this driver ever becomes modularised, it will be really nice
203
 *      to make the epoch retain its value across module reload...
204
 */
205
 
206
static unsigned long epoch = 1900;      /* year corresponding to 0x00   */
207
 
208
static const unsigned char days_in_mo[] =
209
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
210
 
211
/*
212
 * Returns true if a clock update is in progress
213
 */
214
static inline unsigned char rtc_is_updating(void)
215
{
216
        unsigned long flags;
217
        unsigned char uip;
218
 
219
        spin_lock_irqsave(&rtc_lock, flags);
220
        uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
221
        spin_unlock_irqrestore(&rtc_lock, flags);
222
        return uip;
223
}
224
 
225
#ifdef RTC_IRQ
226
/*
227
 *      A very tiny interrupt handler. It runs with IRQF_DISABLED set,
228
 *      but there is possibility of conflicting with the set_rtc_mmss()
229
 *      call (the rtc irq and the timer irq can easily run at the same
230
 *      time in two different CPUs). So we need to serialize
231
 *      accesses to the chip with the rtc_lock spinlock that each
232
 *      architecture should implement in the timer code.
233
 *      (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
234
 */
235
 
236
irqreturn_t rtc_interrupt(int irq, void *dev_id)
237
{
238
        /*
239
         *      Can be an alarm interrupt, update complete interrupt,
240
         *      or a periodic interrupt. We store the status in the
241
         *      low byte and the number of interrupts received since
242
         *      the last read in the remainder of rtc_irq_data.
243
         */
244
 
245
        spin_lock (&rtc_lock);
246
        rtc_irq_data += 0x100;
247
        rtc_irq_data &= ~0xff;
248
        if (is_hpet_enabled()) {
249
                /*
250
                 * In this case it is HPET RTC interrupt handler
251
                 * calling us, with the interrupt information
252
                 * passed as arg1, instead of irq.
253
                 */
254
                rtc_irq_data |= (unsigned long)irq & 0xF0;
255
        } else {
256
                rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
257
        }
258
 
259
        if (rtc_status & RTC_TIMER_ON)
260
                mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
261
 
262
        spin_unlock (&rtc_lock);
263
 
264
        /* Now do the rest of the actions */
265
        spin_lock(&rtc_task_lock);
266
        if (rtc_callback)
267
                rtc_callback->func(rtc_callback->private_data);
268
        spin_unlock(&rtc_task_lock);
269
        wake_up_interruptible(&rtc_wait);
270
 
271
        kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
272
 
273
        return IRQ_HANDLED;
274
}
275
#endif
276
 
277
/*
278
 * sysctl-tuning infrastructure.
279
 */
280
static ctl_table rtc_table[] = {
281
        {
282
                .ctl_name       = CTL_UNNUMBERED,
283
                .procname       = "max-user-freq",
284
                .data           = &rtc_max_user_freq,
285
                .maxlen         = sizeof(int),
286
                .mode           = 0644,
287
                .proc_handler   = &proc_dointvec,
288
        },
289
        { .ctl_name = 0 }
290
};
291
 
292
static ctl_table rtc_root[] = {
293
        {
294
                .ctl_name       = CTL_UNNUMBERED,
295
                .procname       = "rtc",
296
                .mode           = 0555,
297
                .child          = rtc_table,
298
        },
299
        { .ctl_name = 0 }
300
};
301
 
302
static ctl_table dev_root[] = {
303
        {
304
                .ctl_name       = CTL_DEV,
305
                .procname       = "dev",
306
                .mode           = 0555,
307
                .child          = rtc_root,
308
        },
309
        { .ctl_name = 0 }
310
};
311
 
312
static struct ctl_table_header *sysctl_header;
313
 
314
static int __init init_sysctl(void)
315
{
316
    sysctl_header = register_sysctl_table(dev_root);
317
    return 0;
318
}
319
 
320
static void __exit cleanup_sysctl(void)
321
{
322
    unregister_sysctl_table(sysctl_header);
323
}
324
 
325
/*
326
 *      Now all the various file operations that we export.
327
 */
328
 
329
static ssize_t rtc_read(struct file *file, char __user *buf,
330
                        size_t count, loff_t *ppos)
331
{
332
#ifndef RTC_IRQ
333
        return -EIO;
334
#else
335
        DECLARE_WAITQUEUE(wait, current);
336
        unsigned long data;
337
        ssize_t retval;
338
 
339
        if (rtc_has_irq == 0)
340
                return -EIO;
341
 
342
        /*
343
         * Historically this function used to assume that sizeof(unsigned long)
344
         * is the same in userspace and kernelspace.  This lead to problems
345
         * for configurations with multiple ABIs such a the MIPS o32 and 64
346
         * ABIs supported on the same kernel.  So now we support read of both
347
         * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
348
         * userspace ABI.
349
         */
350
        if (count != sizeof(unsigned int) && count !=  sizeof(unsigned long))
351
                return -EINVAL;
352
 
353
        add_wait_queue(&rtc_wait, &wait);
354
 
355
        do {
356
                /* First make it right. Then make it fast. Putting this whole
357
                 * block within the parentheses of a while would be too
358
                 * confusing. And no, xchg() is not the answer. */
359
 
360
                __set_current_state(TASK_INTERRUPTIBLE);
361
 
362
                spin_lock_irq (&rtc_lock);
363
                data = rtc_irq_data;
364
                rtc_irq_data = 0;
365
                spin_unlock_irq (&rtc_lock);
366
 
367
                if (data != 0)
368
                        break;
369
 
370
                if (file->f_flags & O_NONBLOCK) {
371
                        retval = -EAGAIN;
372
                        goto out;
373
                }
374
                if (signal_pending(current)) {
375
                        retval = -ERESTARTSYS;
376
                        goto out;
377
                }
378
                schedule();
379
        } while (1);
380
 
381
        if (count == sizeof(unsigned int))
382
                retval = put_user(data, (unsigned int __user *)buf) ?: sizeof(int);
383
        else
384
                retval = put_user(data, (unsigned long __user *)buf) ?: sizeof(long);
385
        if (!retval)
386
                retval = count;
387
 out:
388
        __set_current_state(TASK_RUNNING);
389
        remove_wait_queue(&rtc_wait, &wait);
390
 
391
        return retval;
392
#endif
393
}
394
 
395
static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
396
{
397
        struct rtc_time wtime;
398
 
399
#ifdef RTC_IRQ
400
        if (rtc_has_irq == 0) {
401
                switch (cmd) {
402
                case RTC_AIE_OFF:
403
                case RTC_AIE_ON:
404
                case RTC_PIE_OFF:
405
                case RTC_PIE_ON:
406
                case RTC_UIE_OFF:
407
                case RTC_UIE_ON:
408
                case RTC_IRQP_READ:
409
                case RTC_IRQP_SET:
410
                        return -EINVAL;
411
                };
412
        }
413
#endif
414
 
415
        switch (cmd) {
416
#ifdef RTC_IRQ
417
        case RTC_AIE_OFF:       /* Mask alarm int. enab. bit    */
418
        {
419
                mask_rtc_irq_bit(RTC_AIE);
420
                return 0;
421
        }
422
        case RTC_AIE_ON:        /* Allow alarm interrupts.      */
423
        {
424
                set_rtc_irq_bit(RTC_AIE);
425
                return 0;
426
        }
427
        case RTC_PIE_OFF:       /* Mask periodic int. enab. bit */
428
        {
429
                unsigned long flags; /* can be called from isr via rtc_control() */
430
                spin_lock_irqsave (&rtc_lock, flags);
431
                mask_rtc_irq_bit_locked(RTC_PIE);
432
                if (rtc_status & RTC_TIMER_ON) {
433
                        rtc_status &= ~RTC_TIMER_ON;
434
                        del_timer(&rtc_irq_timer);
435
                }
436
                spin_unlock_irqrestore (&rtc_lock, flags);
437
                return 0;
438
        }
439
        case RTC_PIE_ON:        /* Allow periodic ints          */
440
        {
441
                unsigned long flags; /* can be called from isr via rtc_control() */
442
                /*
443
                 * We don't really want Joe User enabling more
444
                 * than 64Hz of interrupts on a multi-user machine.
445
                 */
446
                if (!kernel && (rtc_freq > rtc_max_user_freq) &&
447
                        (!capable(CAP_SYS_RESOURCE)))
448
                        return -EACCES;
449
 
450
                spin_lock_irqsave (&rtc_lock, flags);
451
                if (!(rtc_status & RTC_TIMER_ON)) {
452
                        mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
453
                                        2*HZ/100);
454
                        rtc_status |= RTC_TIMER_ON;
455
                }
456
                set_rtc_irq_bit_locked(RTC_PIE);
457
                spin_unlock_irqrestore (&rtc_lock, flags);
458
                return 0;
459
        }
460
        case RTC_UIE_OFF:       /* Mask ints from RTC updates.  */
461
        {
462
                mask_rtc_irq_bit(RTC_UIE);
463
                return 0;
464
        }
465
        case RTC_UIE_ON:        /* Allow ints for RTC updates.  */
466
        {
467
                set_rtc_irq_bit(RTC_UIE);
468
                return 0;
469
        }
470
#endif
471
        case RTC_ALM_READ:      /* Read the present alarm time */
472
        {
473
                /*
474
                 * This returns a struct rtc_time. Reading >= 0xc0
475
                 * means "don't care" or "match all". Only the tm_hour,
476
                 * tm_min, and tm_sec values are filled in.
477
                 */
478
                memset(&wtime, 0, sizeof(struct rtc_time));
479
                get_rtc_alm_time(&wtime);
480
                break;
481
        }
482
        case RTC_ALM_SET:       /* Store a time into the alarm */
483
        {
484
                /*
485
                 * This expects a struct rtc_time. Writing 0xff means
486
                 * "don't care" or "match all". Only the tm_hour,
487
                 * tm_min and tm_sec are used.
488
                 */
489
                unsigned char hrs, min, sec;
490
                struct rtc_time alm_tm;
491
 
492
                if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
493
                                   sizeof(struct rtc_time)))
494
                        return -EFAULT;
495
 
496
                hrs = alm_tm.tm_hour;
497
                min = alm_tm.tm_min;
498
                sec = alm_tm.tm_sec;
499
 
500
                spin_lock_irq(&rtc_lock);
501
                if (hpet_set_alarm_time(hrs, min, sec)) {
502
                        /*
503
                         * Fallthru and set alarm time in CMOS too,
504
                         * so that we will get proper value in RTC_ALM_READ
505
                         */
506
                }
507
                if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
508
                    RTC_ALWAYS_BCD)
509
                {
510
                        if (sec < 60) BIN_TO_BCD(sec);
511
                        else sec = 0xff;
512
 
513
                        if (min < 60) BIN_TO_BCD(min);
514
                        else min = 0xff;
515
 
516
                        if (hrs < 24) BIN_TO_BCD(hrs);
517
                        else hrs = 0xff;
518
                }
519
                CMOS_WRITE(hrs, RTC_HOURS_ALARM);
520
                CMOS_WRITE(min, RTC_MINUTES_ALARM);
521
                CMOS_WRITE(sec, RTC_SECONDS_ALARM);
522
                spin_unlock_irq(&rtc_lock);
523
 
524
                return 0;
525
        }
526
        case RTC_RD_TIME:       /* Read the time/date from RTC  */
527
        {
528
                memset(&wtime, 0, sizeof(struct rtc_time));
529
                rtc_get_rtc_time(&wtime);
530
                break;
531
        }
532
        case RTC_SET_TIME:      /* Set the RTC */
533
        {
534
                struct rtc_time rtc_tm;
535
                unsigned char mon, day, hrs, min, sec, leap_yr;
536
                unsigned char save_control, save_freq_select;
537
                unsigned int yrs;
538
#ifdef CONFIG_MACH_DECSTATION
539
                unsigned int real_yrs;
540
#endif
541
 
542
                if (!capable(CAP_SYS_TIME))
543
                        return -EACCES;
544
 
545
                if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
546
                                   sizeof(struct rtc_time)))
547
                        return -EFAULT;
548
 
549
                yrs = rtc_tm.tm_year + 1900;
550
                mon = rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */
551
                day = rtc_tm.tm_mday;
552
                hrs = rtc_tm.tm_hour;
553
                min = rtc_tm.tm_min;
554
                sec = rtc_tm.tm_sec;
555
 
556
                if (yrs < 1970)
557
                        return -EINVAL;
558
 
559
                leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
560
 
561
                if ((mon > 12) || (day == 0))
562
                        return -EINVAL;
563
 
564
                if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
565
                        return -EINVAL;
566
 
567
                if ((hrs >= 24) || (min >= 60) || (sec >= 60))
568
                        return -EINVAL;
569
 
570
                if ((yrs -= epoch) > 255)    /* They are unsigned */
571
                        return -EINVAL;
572
 
573
                spin_lock_irq(&rtc_lock);
574
#ifdef CONFIG_MACH_DECSTATION
575
                real_yrs = yrs;
576
                yrs = 72;
577
 
578
                /*
579
                 * We want to keep the year set to 73 until March
580
                 * for non-leap years, so that Feb, 29th is handled
581
                 * correctly.
582
                 */
583
                if (!leap_yr && mon < 3) {
584
                        real_yrs--;
585
                        yrs = 73;
586
                }
587
#endif
588
                /* These limits and adjustments are independent of
589
                 * whether the chip is in binary mode or not.
590
                 */
591
                if (yrs > 169) {
592
                        spin_unlock_irq(&rtc_lock);
593
                        return -EINVAL;
594
                }
595
                if (yrs >= 100)
596
                        yrs -= 100;
597
 
598
                if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
599
                    || RTC_ALWAYS_BCD) {
600
                        BIN_TO_BCD(sec);
601
                        BIN_TO_BCD(min);
602
                        BIN_TO_BCD(hrs);
603
                        BIN_TO_BCD(day);
604
                        BIN_TO_BCD(mon);
605
                        BIN_TO_BCD(yrs);
606
                }
607
 
608
                save_control = CMOS_READ(RTC_CONTROL);
609
                CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
610
                save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
611
                CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
612
 
613
#ifdef CONFIG_MACH_DECSTATION
614
                CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
615
#endif
616
                CMOS_WRITE(yrs, RTC_YEAR);
617
                CMOS_WRITE(mon, RTC_MONTH);
618
                CMOS_WRITE(day, RTC_DAY_OF_MONTH);
619
                CMOS_WRITE(hrs, RTC_HOURS);
620
                CMOS_WRITE(min, RTC_MINUTES);
621
                CMOS_WRITE(sec, RTC_SECONDS);
622
 
623
                CMOS_WRITE(save_control, RTC_CONTROL);
624
                CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
625
 
626
                spin_unlock_irq(&rtc_lock);
627
                return 0;
628
        }
629
#ifdef RTC_IRQ
630
        case RTC_IRQP_READ:     /* Read the periodic IRQ rate.  */
631
        {
632
                return put_user(rtc_freq, (unsigned long __user *)arg);
633
        }
634
        case RTC_IRQP_SET:      /* Set periodic IRQ rate.       */
635
        {
636
                int tmp = 0;
637
                unsigned char val;
638
                unsigned long flags; /* can be called from isr via rtc_control() */
639
 
640
                /*
641
                 * The max we can do is 8192Hz.
642
                 */
643
                if ((arg < 2) || (arg > 8192))
644
                        return -EINVAL;
645
                /*
646
                 * We don't really want Joe User generating more
647
                 * than 64Hz of interrupts on a multi-user machine.
648
                 */
649
                if (!kernel && (arg > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
650
                        return -EACCES;
651
 
652
                while (arg > (1<<tmp))
653
                        tmp++;
654
 
655
                /*
656
                 * Check that the input was really a power of 2.
657
                 */
658
                if (arg != (1<<tmp))
659
                        return -EINVAL;
660
 
661
                spin_lock_irqsave(&rtc_lock, flags);
662
                if (hpet_set_periodic_freq(arg)) {
663
                        spin_unlock_irqrestore(&rtc_lock, flags);
664
                        return 0;
665
                }
666
                rtc_freq = arg;
667
 
668
                val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
669
                val |= (16 - tmp);
670
                CMOS_WRITE(val, RTC_FREQ_SELECT);
671
                spin_unlock_irqrestore(&rtc_lock, flags);
672
                return 0;
673
        }
674
#endif
675
        case RTC_EPOCH_READ:    /* Read the epoch.      */
676
        {
677
                return put_user (epoch, (unsigned long __user *)arg);
678
        }
679
        case RTC_EPOCH_SET:     /* Set the epoch.       */
680
        {
681
                /*
682
                 * There were no RTC clocks before 1900.
683
                 */
684
                if (arg < 1900)
685
                        return -EINVAL;
686
 
687
                if (!capable(CAP_SYS_TIME))
688
                        return -EACCES;
689
 
690
                epoch = arg;
691
                return 0;
692
        }
693
        default:
694
                return -ENOTTY;
695
        }
696
        return copy_to_user((void __user *)arg, &wtime, sizeof wtime) ? -EFAULT : 0;
697
}
698
 
699
static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
700
                     unsigned long arg)
701
{
702
        return rtc_do_ioctl(cmd, arg, 0);
703
}
704
 
705
/*
706
 *      We enforce only one user at a time here with the open/close.
707
 *      Also clear the previous interrupt data on an open, and clean
708
 *      up things on a close.
709
 */
710
 
711
/* We use rtc_lock to protect against concurrent opens. So the BKL is not
712
 * needed here. Or anywhere else in this driver. */
713
static int rtc_open(struct inode *inode, struct file *file)
714
{
715
        spin_lock_irq (&rtc_lock);
716
 
717
        if(rtc_status & RTC_IS_OPEN)
718
                goto out_busy;
719
 
720
        rtc_status |= RTC_IS_OPEN;
721
 
722
        rtc_irq_data = 0;
723
        spin_unlock_irq (&rtc_lock);
724
        return 0;
725
 
726
out_busy:
727
        spin_unlock_irq (&rtc_lock);
728
        return -EBUSY;
729
}
730
 
731
static int rtc_fasync (int fd, struct file *filp, int on)
732
 
733
{
734
        return fasync_helper (fd, filp, on, &rtc_async_queue);
735
}
736
 
737
static int rtc_release(struct inode *inode, struct file *file)
738
{
739
#ifdef RTC_IRQ
740
        unsigned char tmp;
741
 
742
        if (rtc_has_irq == 0)
743
                goto no_irq;
744
 
745
        /*
746
         * Turn off all interrupts once the device is no longer
747
         * in use, and clear the data.
748
         */
749
 
750
        spin_lock_irq(&rtc_lock);
751
        if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
752
                tmp = CMOS_READ(RTC_CONTROL);
753
                tmp &=  ~RTC_PIE;
754
                tmp &=  ~RTC_AIE;
755
                tmp &=  ~RTC_UIE;
756
                CMOS_WRITE(tmp, RTC_CONTROL);
757
                CMOS_READ(RTC_INTR_FLAGS);
758
        }
759
        if (rtc_status & RTC_TIMER_ON) {
760
                rtc_status &= ~RTC_TIMER_ON;
761
                del_timer(&rtc_irq_timer);
762
        }
763
        spin_unlock_irq(&rtc_lock);
764
 
765
        if (file->f_flags & FASYNC) {
766
                rtc_fasync (-1, file, 0);
767
        }
768
no_irq:
769
#endif
770
 
771
        spin_lock_irq (&rtc_lock);
772
        rtc_irq_data = 0;
773
        rtc_status &= ~RTC_IS_OPEN;
774
        spin_unlock_irq (&rtc_lock);
775
        return 0;
776
}
777
 
778
#ifdef RTC_IRQ
779
/* Called without the kernel lock - fine */
780
static unsigned int rtc_poll(struct file *file, poll_table *wait)
781
{
782
        unsigned long l;
783
 
784
        if (rtc_has_irq == 0)
785
                return 0;
786
 
787
        poll_wait(file, &rtc_wait, wait);
788
 
789
        spin_lock_irq (&rtc_lock);
790
        l = rtc_irq_data;
791
        spin_unlock_irq (&rtc_lock);
792
 
793
        if (l != 0)
794
                return POLLIN | POLLRDNORM;
795
        return 0;
796
}
797
#endif
798
 
799
/*
800
 * exported stuffs
801
 */
802
 
803
EXPORT_SYMBOL(rtc_register);
804
EXPORT_SYMBOL(rtc_unregister);
805
EXPORT_SYMBOL(rtc_control);
806
 
807
int rtc_register(rtc_task_t *task)
808
{
809
#ifndef RTC_IRQ
810
        return -EIO;
811
#else
812
        if (task == NULL || task->func == NULL)
813
                return -EINVAL;
814
        spin_lock_irq(&rtc_lock);
815
        if (rtc_status & RTC_IS_OPEN) {
816
                spin_unlock_irq(&rtc_lock);
817
                return -EBUSY;
818
        }
819
        spin_lock(&rtc_task_lock);
820
        if (rtc_callback) {
821
                spin_unlock(&rtc_task_lock);
822
                spin_unlock_irq(&rtc_lock);
823
                return -EBUSY;
824
        }
825
        rtc_status |= RTC_IS_OPEN;
826
        rtc_callback = task;
827
        spin_unlock(&rtc_task_lock);
828
        spin_unlock_irq(&rtc_lock);
829
        return 0;
830
#endif
831
}
832
 
833
int rtc_unregister(rtc_task_t *task)
834
{
835
#ifndef RTC_IRQ
836
        return -EIO;
837
#else
838
        unsigned char tmp;
839
 
840
        spin_lock_irq(&rtc_lock);
841
        spin_lock(&rtc_task_lock);
842
        if (rtc_callback != task) {
843
                spin_unlock(&rtc_task_lock);
844
                spin_unlock_irq(&rtc_lock);
845
                return -ENXIO;
846
        }
847
        rtc_callback = NULL;
848
 
849
        /* disable controls */
850
        if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
851
                tmp = CMOS_READ(RTC_CONTROL);
852
                tmp &= ~RTC_PIE;
853
                tmp &= ~RTC_AIE;
854
                tmp &= ~RTC_UIE;
855
                CMOS_WRITE(tmp, RTC_CONTROL);
856
                CMOS_READ(RTC_INTR_FLAGS);
857
        }
858
        if (rtc_status & RTC_TIMER_ON) {
859
                rtc_status &= ~RTC_TIMER_ON;
860
                del_timer(&rtc_irq_timer);
861
        }
862
        rtc_status &= ~RTC_IS_OPEN;
863
        spin_unlock(&rtc_task_lock);
864
        spin_unlock_irq(&rtc_lock);
865
        return 0;
866
#endif
867
}
868
 
869
int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
870
{
871
#ifndef RTC_IRQ
872
        return -EIO;
873
#else
874
        unsigned long flags;
875
        if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
876
                return -EINVAL;
877
        spin_lock_irqsave(&rtc_task_lock, flags);
878
        if (rtc_callback != task) {
879
                spin_unlock_irqrestore(&rtc_task_lock, flags);
880
                return -ENXIO;
881
        }
882
        spin_unlock_irqrestore(&rtc_task_lock, flags);
883
        return rtc_do_ioctl(cmd, arg, 1);
884
#endif
885
}
886
 
887
 
888
/*
889
 *      The various file operations we support.
890
 */
891
 
892
static const struct file_operations rtc_fops = {
893
        .owner          = THIS_MODULE,
894
        .llseek         = no_llseek,
895
        .read           = rtc_read,
896
#ifdef RTC_IRQ
897
        .poll           = rtc_poll,
898
#endif
899
        .ioctl          = rtc_ioctl,
900
        .open           = rtc_open,
901
        .release        = rtc_release,
902
        .fasync         = rtc_fasync,
903
};
904
 
905
static struct miscdevice rtc_dev = {
906
        .minor          = RTC_MINOR,
907
        .name           = "rtc",
908
        .fops           = &rtc_fops,
909
};
910
 
911
#ifdef CONFIG_PROC_FS
912
static const struct file_operations rtc_proc_fops = {
913
        .owner = THIS_MODULE,
914
        .open = rtc_proc_open,
915
        .read  = seq_read,
916
        .llseek = seq_lseek,
917
        .release = single_release,
918
};
919
#endif
920
 
921
static resource_size_t rtc_size;
922
 
923
static struct resource * __init rtc_request_region(resource_size_t size)
924
{
925
        struct resource *r;
926
 
927
        if (RTC_IOMAPPED)
928
                r = request_region(RTC_PORT(0), size, "rtc");
929
        else
930
                r = request_mem_region(RTC_PORT(0), size, "rtc");
931
 
932
        if (r)
933
                rtc_size = size;
934
 
935
        return r;
936
}
937
 
938
static void rtc_release_region(void)
939
{
940
        if (RTC_IOMAPPED)
941
                release_region(RTC_PORT(0), rtc_size);
942
        else
943
                release_mem_region(RTC_PORT(0), rtc_size);
944
}
945
 
946
static int __init rtc_init(void)
947
{
948
#ifdef CONFIG_PROC_FS
949
        struct proc_dir_entry *ent;
950
#endif
951
#if defined(__alpha__) || defined(__mips__)
952
        unsigned int year, ctrl;
953
        char *guess = NULL;
954
#endif
955
#ifdef CONFIG_SPARC32
956
        struct linux_ebus *ebus;
957
        struct linux_ebus_device *edev;
958
#else
959
        void *r;
960
#ifdef RTC_IRQ
961
        irq_handler_t rtc_int_handler_ptr;
962
#endif
963
#endif
964
 
965
#ifdef CONFIG_SPARC32
966
        for_each_ebus(ebus) {
967
                for_each_ebusdev(edev, ebus) {
968
                        if(strcmp(edev->prom_node->name, "rtc") == 0) {
969
                                rtc_port = edev->resource[0].start;
970
                                rtc_irq = edev->irqs[0];
971
                                goto found;
972
                        }
973
                }
974
        }
975
        rtc_has_irq = 0;
976
        printk(KERN_ERR "rtc_init: no PC rtc found\n");
977
        return -EIO;
978
 
979
found:
980
        if (rtc_irq == PCI_IRQ_NONE) {
981
                rtc_has_irq = 0;
982
                goto no_irq;
983
        }
984
 
985
        /*
986
         * XXX Interrupt pin #7 in Espresso is shared between RTC and
987
         * PCI Slot 2 INTA# (and some INTx# in Slot 1).
988
         */
989
        if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc", (void *)&rtc_port)) {
990
                rtc_has_irq = 0;
991
                printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
992
                return -EIO;
993
        }
994
no_irq:
995
#else
996
        r = rtc_request_region(RTC_IO_EXTENT);
997
 
998
        /*
999
         * If we've already requested a smaller range (for example, because
1000
         * PNPBIOS or ACPI told us how the device is configured), the request
1001
         * above might fail because it's too big.
1002
         *
1003
         * If so, request just the range we actually use.
1004
         */
1005
        if (!r)
1006
                r = rtc_request_region(RTC_IO_EXTENT_USED);
1007
        if (!r) {
1008
#ifdef RTC_IRQ
1009
                rtc_has_irq = 0;
1010
#endif
1011
                printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
1012
                       (long)(RTC_PORT(0)));
1013
                return -EIO;
1014
        }
1015
 
1016
#ifdef RTC_IRQ
1017
        if (is_hpet_enabled()) {
1018
                rtc_int_handler_ptr = hpet_rtc_interrupt;
1019
        } else {
1020
                rtc_int_handler_ptr = rtc_interrupt;
1021
        }
1022
 
1023
        if(request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED, "rtc", NULL)) {
1024
                /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
1025
                rtc_has_irq = 0;
1026
                printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
1027
                rtc_release_region();
1028
                return -EIO;
1029
        }
1030
        hpet_rtc_timer_init();
1031
 
1032
#endif
1033
 
1034
#endif /* CONFIG_SPARC32 vs. others */
1035
 
1036
        if (misc_register(&rtc_dev)) {
1037
#ifdef RTC_IRQ
1038
                free_irq(RTC_IRQ, NULL);
1039
                rtc_has_irq = 0;
1040
#endif
1041
                rtc_release_region();
1042
                return -ENODEV;
1043
        }
1044
 
1045
#ifdef CONFIG_PROC_FS
1046
        ent = create_proc_entry("driver/rtc", 0, NULL);
1047
        if (ent)
1048
                ent->proc_fops = &rtc_proc_fops;
1049
        else
1050
                printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
1051
#endif
1052
 
1053
#if defined(__alpha__) || defined(__mips__)
1054
        rtc_freq = HZ;
1055
 
1056
        /* Each operating system on an Alpha uses its own epoch.
1057
           Let's try to guess which one we are using now. */
1058
 
1059
        if (rtc_is_updating() != 0)
1060
                msleep(20);
1061
 
1062
        spin_lock_irq(&rtc_lock);
1063
        year = CMOS_READ(RTC_YEAR);
1064
        ctrl = CMOS_READ(RTC_CONTROL);
1065
        spin_unlock_irq(&rtc_lock);
1066
 
1067
        if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1068
                BCD_TO_BIN(year);       /* This should never happen... */
1069
 
1070
        if (year < 20) {
1071
                epoch = 2000;
1072
                guess = "SRM (post-2000)";
1073
        } else if (year >= 20 && year < 48) {
1074
                epoch = 1980;
1075
                guess = "ARC console";
1076
        } else if (year >= 48 && year < 72) {
1077
                epoch = 1952;
1078
                guess = "Digital UNIX";
1079
#if defined(__mips__)
1080
        } else if (year >= 72 && year < 74) {
1081
                epoch = 2000;
1082
                guess = "Digital DECstation";
1083
#else
1084
        } else if (year >= 70) {
1085
                epoch = 1900;
1086
                guess = "Standard PC (1900)";
1087
#endif
1088
        }
1089
        if (guess)
1090
                printk(KERN_INFO "rtc: %s epoch (%lu) detected\n", guess, epoch);
1091
#endif
1092
#ifdef RTC_IRQ
1093
        if (rtc_has_irq == 0)
1094
                goto no_irq2;
1095
 
1096
        spin_lock_irq(&rtc_lock);
1097
        rtc_freq = 1024;
1098
        if (!hpet_set_periodic_freq(rtc_freq)) {
1099
                /* Initialize periodic freq. to CMOS reset default, which is 1024Hz */
1100
                CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06), RTC_FREQ_SELECT);
1101
        }
1102
        spin_unlock_irq(&rtc_lock);
1103
no_irq2:
1104
#endif
1105
 
1106
        (void) init_sysctl();
1107
 
1108
        printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1109
 
1110
        return 0;
1111
}
1112
 
1113
static void __exit rtc_exit (void)
1114
{
1115
        cleanup_sysctl();
1116
        remove_proc_entry ("driver/rtc", NULL);
1117
        misc_deregister(&rtc_dev);
1118
 
1119
#ifdef CONFIG_SPARC32
1120
        if (rtc_has_irq)
1121
                free_irq (rtc_irq, &rtc_port);
1122
#else
1123
        rtc_release_region();
1124
#ifdef RTC_IRQ
1125
        if (rtc_has_irq)
1126
                free_irq (RTC_IRQ, NULL);
1127
#endif
1128
#endif /* CONFIG_SPARC32 */
1129
}
1130
 
1131
module_init(rtc_init);
1132
module_exit(rtc_exit);
1133
 
1134
#ifdef RTC_IRQ
1135
/*
1136
 *      At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
1137
 *      (usually during an IDE disk interrupt, with IRQ unmasking off)
1138
 *      Since the interrupt handler doesn't get called, the IRQ status
1139
 *      byte doesn't get read, and the RTC stops generating interrupts.
1140
 *      A timer is set, and will call this function if/when that happens.
1141
 *      To get it out of this stalled state, we just read the status.
1142
 *      At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
1143
 *      (You *really* shouldn't be trying to use a non-realtime system
1144
 *      for something that requires a steady > 1KHz signal anyways.)
1145
 */
1146
 
1147
static void rtc_dropped_irq(unsigned long data)
1148
{
1149
        unsigned long freq;
1150
 
1151
        spin_lock_irq (&rtc_lock);
1152
 
1153
        if (hpet_rtc_dropped_irq()) {
1154
                spin_unlock_irq(&rtc_lock);
1155
                return;
1156
        }
1157
 
1158
        /* Just in case someone disabled the timer from behind our back... */
1159
        if (rtc_status & RTC_TIMER_ON)
1160
                mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
1161
 
1162
        rtc_irq_data += ((rtc_freq/HZ)<<8);
1163
        rtc_irq_data &= ~0xff;
1164
        rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);     /* restart */
1165
 
1166
        freq = rtc_freq;
1167
 
1168
        spin_unlock_irq(&rtc_lock);
1169
 
1170
        if (printk_ratelimit())
1171
                printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n", freq);
1172
 
1173
        /* Now we have new data */
1174
        wake_up_interruptible(&rtc_wait);
1175
 
1176
        kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
1177
}
1178
#endif
1179
 
1180
#ifdef CONFIG_PROC_FS
1181
/*
1182
 *      Info exported via "/proc/driver/rtc".
1183
 */
1184
 
1185
static int rtc_proc_show(struct seq_file *seq, void *v)
1186
{
1187
#define YN(bit) ((ctrl & bit) ? "yes" : "no")
1188
#define NY(bit) ((ctrl & bit) ? "no" : "yes")
1189
        struct rtc_time tm;
1190
        unsigned char batt, ctrl;
1191
        unsigned long freq;
1192
 
1193
        spin_lock_irq(&rtc_lock);
1194
        batt = CMOS_READ(RTC_VALID) & RTC_VRT;
1195
        ctrl = CMOS_READ(RTC_CONTROL);
1196
        freq = rtc_freq;
1197
        spin_unlock_irq(&rtc_lock);
1198
 
1199
 
1200
        rtc_get_rtc_time(&tm);
1201
 
1202
        /*
1203
         * There is no way to tell if the luser has the RTC set for local
1204
         * time or for Universal Standard Time (GMT). Probably local though.
1205
         */
1206
        seq_printf(seq,
1207
                   "rtc_time\t: %02d:%02d:%02d\n"
1208
                   "rtc_date\t: %04d-%02d-%02d\n"
1209
                   "rtc_epoch\t: %04lu\n",
1210
                   tm.tm_hour, tm.tm_min, tm.tm_sec,
1211
                   tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
1212
 
1213
        get_rtc_alm_time(&tm);
1214
 
1215
        /*
1216
         * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
1217
         * match any value for that particular field. Values that are
1218
         * greater than a valid time, but less than 0xc0 shouldn't appear.
1219
         */
1220
        seq_puts(seq, "alarm\t\t: ");
1221
        if (tm.tm_hour <= 24)
1222
                seq_printf(seq, "%02d:", tm.tm_hour);
1223
        else
1224
                seq_puts(seq, "**:");
1225
 
1226
        if (tm.tm_min <= 59)
1227
                seq_printf(seq, "%02d:", tm.tm_min);
1228
        else
1229
                seq_puts(seq, "**:");
1230
 
1231
        if (tm.tm_sec <= 59)
1232
                seq_printf(seq, "%02d\n", tm.tm_sec);
1233
        else
1234
                seq_puts(seq, "**\n");
1235
 
1236
        seq_printf(seq,
1237
                   "DST_enable\t: %s\n"
1238
                   "BCD\t\t: %s\n"
1239
                   "24hr\t\t: %s\n"
1240
                   "square_wave\t: %s\n"
1241
                   "alarm_IRQ\t: %s\n"
1242
                   "update_IRQ\t: %s\n"
1243
                   "periodic_IRQ\t: %s\n"
1244
                   "periodic_freq\t: %ld\n"
1245
                   "batt_status\t: %s\n",
1246
                   YN(RTC_DST_EN),
1247
                   NY(RTC_DM_BINARY),
1248
                   YN(RTC_24H),
1249
                   YN(RTC_SQWE),
1250
                   YN(RTC_AIE),
1251
                   YN(RTC_UIE),
1252
                   YN(RTC_PIE),
1253
                   freq,
1254
                   batt ? "okay" : "dead");
1255
 
1256
        return  0;
1257
#undef YN
1258
#undef NY
1259
}
1260
 
1261
static int rtc_proc_open(struct inode *inode, struct file *file)
1262
{
1263
        return single_open(file, rtc_proc_show, NULL);
1264
}
1265
#endif
1266
 
1267
void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1268
{
1269
        unsigned long uip_watchdog = jiffies, flags;
1270
        unsigned char ctrl;
1271
#ifdef CONFIG_MACH_DECSTATION
1272
        unsigned int real_year;
1273
#endif
1274
 
1275
        /*
1276
         * read RTC once any update in progress is done. The update
1277
         * can take just over 2ms. We wait 20ms. There is no need to
1278
         * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
1279
         * If you need to know *exactly* when a second has started, enable
1280
         * periodic update complete interrupts, (via ioctl) and then
1281
         * immediately read /dev/rtc which will block until you get the IRQ.
1282
         * Once the read clears, read the RTC time (again via ioctl). Easy.
1283
         */
1284
 
1285
        while (rtc_is_updating() != 0 && jiffies - uip_watchdog < 2*HZ/100)
1286
                cpu_relax();
1287
 
1288
        /*
1289
         * Only the values that we read from the RTC are set. We leave
1290
         * tm_wday, tm_yday and tm_isdst untouched. Note that while the
1291
         * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
1292
         * only updated by the RTC when initially set to a non-zero value.
1293
         */
1294
        spin_lock_irqsave(&rtc_lock, flags);
1295
        rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1296
        rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1297
        rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1298
        rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1299
        rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1300
        rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1301
        /* Only set from 2.6.16 onwards */
1302
        rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
1303
 
1304
#ifdef CONFIG_MACH_DECSTATION
1305
        real_year = CMOS_READ(RTC_DEC_YEAR);
1306
#endif
1307
        ctrl = CMOS_READ(RTC_CONTROL);
1308
        spin_unlock_irqrestore(&rtc_lock, flags);
1309
 
1310
        if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1311
        {
1312
                BCD_TO_BIN(rtc_tm->tm_sec);
1313
                BCD_TO_BIN(rtc_tm->tm_min);
1314
                BCD_TO_BIN(rtc_tm->tm_hour);
1315
                BCD_TO_BIN(rtc_tm->tm_mday);
1316
                BCD_TO_BIN(rtc_tm->tm_mon);
1317
                BCD_TO_BIN(rtc_tm->tm_year);
1318
                BCD_TO_BIN(rtc_tm->tm_wday);
1319
        }
1320
 
1321
#ifdef CONFIG_MACH_DECSTATION
1322
        rtc_tm->tm_year += real_year - 72;
1323
#endif
1324
 
1325
        /*
1326
         * Account for differences between how the RTC uses the values
1327
         * and how they are defined in a struct rtc_time;
1328
         */
1329
        if ((rtc_tm->tm_year += (epoch - 1900)) <= 69)
1330
                rtc_tm->tm_year += 100;
1331
 
1332
        rtc_tm->tm_mon--;
1333
}
1334
 
1335
static void get_rtc_alm_time(struct rtc_time *alm_tm)
1336
{
1337
        unsigned char ctrl;
1338
 
1339
        /*
1340
         * Only the values that we read from the RTC are set. That
1341
         * means only tm_hour, tm_min, and tm_sec.
1342
         */
1343
        spin_lock_irq(&rtc_lock);
1344
        alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
1345
        alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
1346
        alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
1347
        ctrl = CMOS_READ(RTC_CONTROL);
1348
        spin_unlock_irq(&rtc_lock);
1349
 
1350
        if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
1351
        {
1352
                BCD_TO_BIN(alm_tm->tm_sec);
1353
                BCD_TO_BIN(alm_tm->tm_min);
1354
                BCD_TO_BIN(alm_tm->tm_hour);
1355
        }
1356
}
1357
 
1358
#ifdef RTC_IRQ
1359
/*
1360
 * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
1361
 * Rumour has it that if you frob the interrupt enable/disable
1362
 * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
1363
 * ensure you actually start getting interrupts. Probably for
1364
 * compatibility with older/broken chipset RTC implementations.
1365
 * We also clear out any old irq data after an ioctl() that
1366
 * meddles with the interrupt enable/disable bits.
1367
 */
1368
 
1369
static void mask_rtc_irq_bit_locked(unsigned char bit)
1370
{
1371
        unsigned char val;
1372
 
1373
        if (hpet_mask_rtc_irq_bit(bit))
1374
                return;
1375
        val = CMOS_READ(RTC_CONTROL);
1376
        val &=  ~bit;
1377
        CMOS_WRITE(val, RTC_CONTROL);
1378
        CMOS_READ(RTC_INTR_FLAGS);
1379
 
1380
        rtc_irq_data = 0;
1381
}
1382
 
1383
static void set_rtc_irq_bit_locked(unsigned char bit)
1384
{
1385
        unsigned char val;
1386
 
1387
        if (hpet_set_rtc_irq_bit(bit))
1388
                return;
1389
        val = CMOS_READ(RTC_CONTROL);
1390
        val |= bit;
1391
        CMOS_WRITE(val, RTC_CONTROL);
1392
        CMOS_READ(RTC_INTR_FLAGS);
1393
 
1394
        rtc_irq_data = 0;
1395
}
1396
#endif
1397
 
1398
MODULE_AUTHOR("Paul Gortmaker");
1399
MODULE_LICENSE("GPL");
1400
MODULE_ALIAS_MISCDEV(RTC_MINOR);

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.