MIPS: Malta: Change CPU default to R2.
[linux-2.6.git] / drivers / char / vr41xx_rtc.c
1 /*
2  *  Driver for NEC VR4100 series  Real Time Clock unit.
3  *
4  *  Copyright (C) 2003-2005  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 #include <linux/platform_device.h>
21 #include <linux/fs.h>
22 #include <linux/init.h>
23 #include <linux/ioport.h>
24 #include <linux/irq.h>
25 #include <linux/mc146818rtc.h>
26 #include <linux/miscdevice.h>
27 #include <linux/module.h>
28 #include <linux/poll.h>
29 #include <linux/rtc.h>
30 #include <linux/spinlock.h>
31 #include <linux/types.h>
32 #include <linux/wait.h>
33
34 #include <asm/div64.h>
35 #include <asm/io.h>
36 #include <asm/time.h>
37 #include <asm/uaccess.h>
38 #include <asm/vr41xx/vr41xx.h>
39
40 MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
41 MODULE_DESCRIPTION("NEC VR4100 series RTC driver");
42 MODULE_LICENSE("GPL");
43
44 #define RTC1_TYPE1_START        0x0b0000c0UL
45 #define RTC1_TYPE1_END          0x0b0000dfUL
46 #define RTC2_TYPE1_START        0x0b0001c0UL
47 #define RTC2_TYPE1_END          0x0b0001dfUL
48
49 #define RTC1_TYPE2_START        0x0f000100UL
50 #define RTC1_TYPE2_END          0x0f00011fUL
51 #define RTC2_TYPE2_START        0x0f000120UL
52 #define RTC2_TYPE2_END          0x0f00013fUL
53
54 #define RTC1_SIZE               0x20
55 #define RTC2_SIZE               0x20
56
57 /* RTC 1 registers */
58 #define ETIMELREG               0x00
59 #define ETIMEMREG               0x02
60 #define ETIMEHREG               0x04
61 /* RFU */
62 #define ECMPLREG                0x08
63 #define ECMPMREG                0x0a
64 #define ECMPHREG                0x0c
65 /* RFU */
66 #define RTCL1LREG               0x10
67 #define RTCL1HREG               0x12
68 #define RTCL1CNTLREG            0x14
69 #define RTCL1CNTHREG            0x16
70 #define RTCL2LREG               0x18
71 #define RTCL2HREG               0x1a
72 #define RTCL2CNTLREG            0x1c
73 #define RTCL2CNTHREG            0x1e
74
75 /* RTC 2 registers */
76 #define TCLKLREG                0x00
77 #define TCLKHREG                0x02
78 #define TCLKCNTLREG             0x04
79 #define TCLKCNTHREG             0x06
80 /* RFU */
81 #define RTCINTREG               0x1e
82  #define TCLOCK_INT             0x08
83  #define RTCLONG2_INT           0x04
84  #define RTCLONG1_INT           0x02
85  #define ELAPSEDTIME_INT        0x01
86
87 #define RTC_FREQUENCY           32768
88 #define MAX_PERIODIC_RATE       6553
89 #define MAX_USER_PERIODIC_RATE  64
90
91 static void __iomem *rtc1_base;
92 static void __iomem *rtc2_base;
93
94 #define rtc1_read(offset)               readw(rtc1_base + (offset))
95 #define rtc1_write(offset, value)       writew((value), rtc1_base + (offset))
96
97 #define rtc2_read(offset)               readw(rtc2_base + (offset))
98 #define rtc2_write(offset, value)       writew((value), rtc2_base + (offset))
99
100 static unsigned long epoch = 1970;      /* Jan 1 1970 00:00:00 */
101
102 static spinlock_t rtc_task_lock;
103 static wait_queue_head_t rtc_wait;
104 static unsigned long rtc_irq_data;
105 static struct fasync_struct *rtc_async_queue;
106 static rtc_task_t *rtc_callback;
107 static char rtc_name[] = "RTC";
108 static unsigned long periodic_frequency;
109 static unsigned long periodic_count;
110
111 typedef enum {
112         RTC_RELEASE,
113         RTC_OPEN,
114 } rtc_status_t;
115
116 static rtc_status_t rtc_status;
117
118 typedef enum {
119         FUNCTION_RTC_IOCTL,
120         FUNCTION_RTC_CONTROL,
121 } rtc_callfrom_t;
122
123 struct resource rtc_resource[2] = {
124         {       .name   = rtc_name,
125                 .flags  = IORESOURCE_MEM,       },
126         {       .name   = rtc_name,
127                 .flags  = IORESOURCE_MEM,       },
128 };
129
130 #define RTC_NUM_RESOURCES       sizeof(rtc_resource) / sizeof(struct resource)
131
132 static inline unsigned long read_elapsed_second(void)
133 {
134         unsigned long first_low, first_mid, first_high;
135         unsigned long second_low, second_mid, second_high;
136
137         do {
138                 first_low = rtc1_read(ETIMELREG);
139                 first_mid = rtc1_read(ETIMEMREG);
140                 first_high = rtc1_read(ETIMEHREG);
141                 second_low = rtc1_read(ETIMELREG);
142                 second_mid = rtc1_read(ETIMEMREG);
143                 second_high = rtc1_read(ETIMEHREG);
144         } while (first_low != second_low || first_mid != second_mid ||
145                  first_high != second_high);
146
147         return (first_high << 17) | (first_mid << 1) | (first_low >> 15);
148 }
149
150 static inline void write_elapsed_second(unsigned long sec)
151 {
152         spin_lock_irq(&rtc_lock);
153
154         rtc1_write(ETIMELREG, (uint16_t)(sec << 15));
155         rtc1_write(ETIMEMREG, (uint16_t)(sec >> 1));
156         rtc1_write(ETIMEHREG, (uint16_t)(sec >> 17));
157
158         spin_unlock_irq(&rtc_lock);
159 }
160
161 static void set_alarm(struct rtc_time *time)
162 {
163         unsigned long alarm_sec;
164
165         alarm_sec = mktime(time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
166                            time->tm_hour, time->tm_min, time->tm_sec);
167
168         spin_lock_irq(&rtc_lock);
169
170         rtc1_write(ECMPLREG, (uint16_t)(alarm_sec << 15));
171         rtc1_write(ECMPMREG, (uint16_t)(alarm_sec >> 1));
172         rtc1_write(ECMPHREG, (uint16_t)(alarm_sec >> 17));
173
174         spin_unlock_irq(&rtc_lock);
175 }
176
177 static void read_alarm(struct rtc_time *time)
178 {
179         unsigned long low, mid, high;
180
181         spin_lock_irq(&rtc_lock);
182
183         low = rtc1_read(ECMPLREG);
184         mid = rtc1_read(ECMPMREG);
185         high = rtc1_read(ECMPHREG);
186
187         spin_unlock_irq(&rtc_lock);
188
189         to_tm((high << 17) | (mid << 1) | (low >> 15), time);
190         time->tm_year -= 1900;
191 }
192
193 static void read_time(struct rtc_time *time)
194 {
195         unsigned long epoch_sec, elapsed_sec;
196
197         epoch_sec = mktime(epoch, 1, 1, 0, 0, 0);
198         elapsed_sec = read_elapsed_second();
199
200         to_tm(epoch_sec + elapsed_sec, time);
201         time->tm_year -= 1900;
202 }
203
204 static void set_time(struct rtc_time *time)
205 {
206         unsigned long epoch_sec, current_sec;
207
208         epoch_sec = mktime(epoch, 1, 1, 0, 0, 0);
209         current_sec = mktime(time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
210                              time->tm_hour, time->tm_min, time->tm_sec);
211
212         write_elapsed_second(current_sec - epoch_sec);
213 }
214
215 static ssize_t rtc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
216 {
217         DECLARE_WAITQUEUE(wait, current);
218         unsigned long irq_data;
219         int retval = 0;
220
221         if (count != sizeof(unsigned int) && count != sizeof(unsigned long))
222                 return -EINVAL;
223
224         add_wait_queue(&rtc_wait, &wait);
225
226         do {
227                 __set_current_state(TASK_INTERRUPTIBLE);
228
229                 spin_lock_irq(&rtc_lock);
230                 irq_data = rtc_irq_data;
231                 rtc_irq_data = 0;
232                 spin_unlock_irq(&rtc_lock);
233
234                 if (irq_data != 0)
235                         break;
236
237                 if (file->f_flags & O_NONBLOCK) {
238                         retval = -EAGAIN;
239                         break;
240                 }
241
242                 if (signal_pending(current)) {
243                         retval = -ERESTARTSYS;
244                         break;
245                 }
246         } while (1);
247
248         if (retval == 0) {
249                 if (count == sizeof(unsigned int)) {
250                         retval = put_user(irq_data, (unsigned int __user *)buf);
251                         if (retval == 0)
252                                 retval = sizeof(unsigned int);
253                 } else {
254                         retval = put_user(irq_data, (unsigned long __user *)buf);
255                         if (retval == 0)
256                                 retval = sizeof(unsigned long);
257                 }
258
259         }
260
261         __set_current_state(TASK_RUNNING);
262         remove_wait_queue(&rtc_wait, &wait);
263
264         return retval;
265 }
266
267 static unsigned int rtc_poll(struct file *file, struct poll_table_struct *table)
268 {
269         poll_wait(file, &rtc_wait, table);
270
271         if (rtc_irq_data != 0)
272                 return POLLIN | POLLRDNORM;
273
274         return 0;
275 }
276
277 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, rtc_callfrom_t from)
278 {
279         struct rtc_time time;
280         unsigned long count;
281
282         switch (cmd) {
283         case RTC_AIE_ON:
284                 enable_irq(ELAPSEDTIME_IRQ);
285                 break;
286         case RTC_AIE_OFF:
287                 disable_irq(ELAPSEDTIME_IRQ);
288                 break;
289         case RTC_PIE_ON:
290                 enable_irq(RTCLONG1_IRQ);
291                 break;
292         case RTC_PIE_OFF:
293                 disable_irq(RTCLONG1_IRQ);
294                 break;
295         case RTC_ALM_SET:
296                 if (copy_from_user(&time, (struct rtc_time __user *)arg,
297                                    sizeof(struct rtc_time)))
298                         return -EFAULT;
299
300                 set_alarm(&time);
301                 break;
302         case RTC_ALM_READ:
303                 memset(&time, 0, sizeof(struct rtc_time));
304                 read_alarm(&time);
305                 break;
306         case RTC_RD_TIME:
307                 memset(&time, 0, sizeof(struct rtc_time));
308                 read_time(&time);
309                 if (copy_to_user((void __user *)arg, &time, sizeof(struct rtc_time)))
310                         return -EFAULT;
311                 break;
312         case RTC_SET_TIME:
313                 if (capable(CAP_SYS_TIME) == 0)
314                         return -EACCES;
315
316                 if (copy_from_user(&time, (struct rtc_time __user *)arg,
317                                    sizeof(struct rtc_time)))
318                         return -EFAULT;
319
320                 set_time(&time);
321                 break;
322         case RTC_IRQP_READ:
323                 return put_user(periodic_frequency, (unsigned long __user *)arg);
324                 break;
325         case RTC_IRQP_SET:
326                 if (arg > MAX_PERIODIC_RATE)
327                         return -EINVAL;
328
329                 if (from == FUNCTION_RTC_IOCTL && arg > MAX_USER_PERIODIC_RATE &&
330                     capable(CAP_SYS_RESOURCE) == 0)
331                         return -EACCES;
332
333                 periodic_frequency = arg;
334
335                 count = RTC_FREQUENCY;
336                 do_div(count, arg);
337
338                 periodic_count = count;
339
340                 spin_lock_irq(&rtc_lock);
341
342                 rtc1_write(RTCL1LREG, count);
343                 rtc1_write(RTCL1HREG, count >> 16);
344
345                 spin_unlock_irq(&rtc_lock);
346                 break;
347         case RTC_EPOCH_READ:
348                 return put_user(epoch, (unsigned long __user *)arg);
349         case RTC_EPOCH_SET:
350                 /* Doesn't support before 1900 */
351                 if (arg < 1900)
352                         return -EINVAL;
353
354                 if (capable(CAP_SYS_TIME) == 0)
355                         return -EACCES;
356
357                 epoch = arg;
358                 break;
359         default:
360                 return -EINVAL;
361         }
362
363         return 0;
364 }
365
366 static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
367                      unsigned long arg)
368 {
369         return rtc_do_ioctl(cmd, arg, FUNCTION_RTC_IOCTL);
370 }
371
372 static int rtc_open(struct inode *inode, struct file *file)
373 {
374         spin_lock_irq(&rtc_lock);
375
376         if (rtc_status == RTC_OPEN) {
377                 spin_unlock_irq(&rtc_lock);
378                 return -EBUSY;
379         }
380
381         rtc_status = RTC_OPEN;
382         rtc_irq_data = 0;
383
384         spin_unlock_irq(&rtc_lock);
385
386         return 0;
387 }
388
389 static int rtc_release(struct inode *inode, struct file *file)
390 {
391         if (file->f_flags & FASYNC)
392                 (void)fasync_helper(-1, file, 0, &rtc_async_queue);
393
394         spin_lock_irq(&rtc_lock);
395
396         rtc1_write(ECMPLREG, 0);
397         rtc1_write(ECMPMREG, 0);
398         rtc1_write(ECMPHREG, 0);
399         rtc1_write(RTCL1LREG, 0);
400         rtc1_write(RTCL1HREG, 0);
401
402         rtc_status = RTC_RELEASE;
403
404         spin_unlock_irq(&rtc_lock);
405
406         disable_irq(ELAPSEDTIME_IRQ);
407         disable_irq(RTCLONG1_IRQ);
408
409         return 0;
410 }
411
412 static int rtc_fasync(int fd, struct file *file, int on)
413 {
414         return fasync_helper(fd, file, on, &rtc_async_queue);
415 }
416
417 static struct file_operations rtc_fops = {
418         .owner          = THIS_MODULE,
419         .llseek         = no_llseek,
420         .read           = rtc_read,
421         .poll           = rtc_poll,
422         .ioctl          = rtc_ioctl,
423         .open           = rtc_open,
424         .release        = rtc_release,
425         .fasync         = rtc_fasync,
426 };
427
428 static irqreturn_t elapsedtime_interrupt(int irq, void *dev_id, struct pt_regs *regs)
429 {
430         spin_lock(&rtc_lock);
431         rtc2_write(RTCINTREG, ELAPSEDTIME_INT);
432
433         rtc_irq_data += 0x100;
434         rtc_irq_data &= ~0xff;
435         rtc_irq_data |= RTC_AF;
436         spin_unlock(&rtc_lock);
437
438         spin_lock(&rtc_lock);
439         if (rtc_callback)
440                 rtc_callback->func(rtc_callback->private_data);
441         spin_unlock(&rtc_lock);
442
443         wake_up_interruptible(&rtc_wait);
444
445         kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
446
447         return IRQ_HANDLED;
448 }
449
450 static irqreturn_t rtclong1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
451 {
452         unsigned long count = periodic_count;
453
454         spin_lock(&rtc_lock);
455         rtc2_write(RTCINTREG, RTCLONG1_INT);
456
457         rtc1_write(RTCL1LREG, count);
458         rtc1_write(RTCL1HREG, count >> 16);
459
460         rtc_irq_data += 0x100;
461         rtc_irq_data &= ~0xff;
462         rtc_irq_data |= RTC_PF;
463         spin_unlock(&rtc_lock);
464
465         spin_lock(&rtc_task_lock);
466         if (rtc_callback)
467                 rtc_callback->func(rtc_callback->private_data);
468         spin_unlock(&rtc_task_lock);
469
470         wake_up_interruptible(&rtc_wait);
471
472         kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
473
474         return IRQ_HANDLED;
475 }
476
477 int rtc_register(rtc_task_t *task)
478 {
479         if (task == NULL || task->func == NULL)
480                 return -EINVAL;
481
482         spin_lock_irq(&rtc_lock);
483         if (rtc_status == RTC_OPEN) {
484                 spin_unlock_irq(&rtc_lock);
485                 return -EBUSY;
486         }
487
488         spin_lock(&rtc_task_lock);
489         if (rtc_callback != NULL) {
490                 spin_unlock(&rtc_task_lock);
491                 spin_unlock_irq(&rtc_task_lock);
492                 return -EBUSY;
493         }
494
495         rtc_callback = task;
496         spin_unlock(&rtc_task_lock);
497
498         rtc_status = RTC_OPEN;
499
500         spin_unlock_irq(&rtc_lock);
501
502         return 0;
503 }
504
505 EXPORT_SYMBOL_GPL(rtc_register);
506
507 int rtc_unregister(rtc_task_t *task)
508 {
509         spin_lock_irq(&rtc_task_lock);
510         if (task == NULL || rtc_callback != task) {
511                 spin_unlock_irq(&rtc_task_lock);
512                 return -ENXIO;
513         }
514
515         spin_lock(&rtc_lock);
516
517         rtc1_write(ECMPLREG, 0);
518         rtc1_write(ECMPMREG, 0);
519         rtc1_write(ECMPHREG, 0);
520         rtc1_write(RTCL1LREG, 0);
521         rtc1_write(RTCL1HREG, 0);
522
523         rtc_status = RTC_RELEASE;
524
525         spin_unlock(&rtc_lock);
526
527         rtc_callback = NULL;
528
529         spin_unlock_irq(&rtc_task_lock);
530
531         disable_irq(ELAPSEDTIME_IRQ);
532         disable_irq(RTCLONG1_IRQ);
533
534         return 0;
535 }
536
537 EXPORT_SYMBOL_GPL(rtc_unregister);
538
539 int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
540 {
541         int retval = 0;
542
543         spin_lock_irq(&rtc_task_lock);
544
545         if (rtc_callback != task)
546                 retval = -ENXIO;
547         else
548                 rtc_do_ioctl(cmd, arg, FUNCTION_RTC_CONTROL);
549
550         spin_unlock_irq(&rtc_task_lock);
551
552         return retval;
553 }
554
555 EXPORT_SYMBOL_GPL(rtc_control);
556
557 static struct miscdevice rtc_miscdevice = {
558         .minor  = RTC_MINOR,
559         .name   = rtc_name,
560         .fops   = &rtc_fops,
561 };
562
563 static int rtc_probe(struct platform_device *pdev)
564 {
565         unsigned int irq;
566         int retval;
567
568         if (pdev->num_resources != 2)
569                 return -EBUSY;
570
571         rtc1_base = ioremap(pdev->resource[0].start, RTC1_SIZE);
572         if (rtc1_base == NULL)
573                 return -EBUSY;
574
575         rtc2_base = ioremap(pdev->resource[1].start, RTC2_SIZE);
576         if (rtc2_base == NULL) {
577                 iounmap(rtc1_base);
578                 rtc1_base = NULL;
579                 return -EBUSY;
580         }
581
582         retval = misc_register(&rtc_miscdevice);
583         if (retval < 0) {
584                 iounmap(rtc1_base);
585                 iounmap(rtc2_base);
586                 rtc1_base = NULL;
587                 rtc2_base = NULL;
588                 return retval;
589         }
590
591         spin_lock_irq(&rtc_lock);
592
593         rtc1_write(ECMPLREG, 0);
594         rtc1_write(ECMPMREG, 0);
595         rtc1_write(ECMPHREG, 0);
596         rtc1_write(RTCL1LREG, 0);
597         rtc1_write(RTCL1HREG, 0);
598
599         rtc_status = RTC_RELEASE;
600         rtc_irq_data = 0;
601
602         spin_unlock_irq(&rtc_lock);
603
604         init_waitqueue_head(&rtc_wait);
605
606         irq = ELAPSEDTIME_IRQ;
607         retval = request_irq(irq, elapsedtime_interrupt, SA_INTERRUPT,
608                              "elapsed_time", NULL);
609         if (retval == 0) {
610                 irq = RTCLONG1_IRQ;
611                 retval = request_irq(irq, rtclong1_interrupt, SA_INTERRUPT,
612                                      "rtclong1", NULL);
613         }
614
615         if (retval < 0) {
616                 printk(KERN_ERR "rtc: IRQ%d is busy\n", irq);
617                 if (irq == RTCLONG1_IRQ)
618                         free_irq(ELAPSEDTIME_IRQ, NULL);
619                 iounmap(rtc1_base);
620                 iounmap(rtc2_base);
621                 rtc1_base = NULL;
622                 rtc2_base = NULL;
623                 return retval;
624         }
625
626         disable_irq(ELAPSEDTIME_IRQ);
627         disable_irq(RTCLONG1_IRQ);
628
629         spin_lock_init(&rtc_task_lock);
630
631         printk(KERN_INFO "rtc: Real Time Clock of NEC VR4100 series\n");
632
633         return 0;
634 }
635
636 static int rtc_remove(struct platform_device *dev)
637 {
638         int retval;
639
640         retval = misc_deregister(&rtc_miscdevice);
641         if (retval < 0)
642                 return retval;
643
644         free_irq(ELAPSEDTIME_IRQ, NULL);
645         free_irq(RTCLONG1_IRQ, NULL);
646         if (rtc1_base != NULL)
647                 iounmap(rtc1_base);
648         if (rtc2_base != NULL)
649                 iounmap(rtc2_base);
650
651         return 0;
652 }
653
654 static struct platform_device *rtc_platform_device;
655
656 static struct platform_driver rtc_device_driver = {
657         .probe          = rtc_probe,
658         .remove         = rtc_remove,
659         .driver         = {
660                 .name   = rtc_name,
661         },
662 };
663
664 static int __devinit vr41xx_rtc_init(void)
665 {
666         int retval;
667
668         switch (current_cpu_data.cputype) {
669         case CPU_VR4111:
670         case CPU_VR4121:
671                 rtc_resource[0].start = RTC1_TYPE1_START;
672                 rtc_resource[0].end = RTC1_TYPE1_END;
673                 rtc_resource[1].start = RTC2_TYPE1_START;
674                 rtc_resource[1].end = RTC2_TYPE1_END;
675                 break;
676         case CPU_VR4122:
677         case CPU_VR4131:
678         case CPU_VR4133:
679                 rtc_resource[0].start = RTC1_TYPE2_START;
680                 rtc_resource[0].end = RTC1_TYPE2_END;
681                 rtc_resource[1].start = RTC2_TYPE2_START;
682                 rtc_resource[1].end = RTC2_TYPE2_END;
683                 break;
684         default:
685                 return -ENODEV;
686                 break;
687         }
688
689         rtc_platform_device = platform_device_register_simple("RTC", -1, rtc_resource, RTC_NUM_RESOURCES);
690         if (IS_ERR(rtc_platform_device))
691                 return PTR_ERR(rtc_platform_device);
692
693         retval = platform_driver_register(&rtc_device_driver);
694         if (retval < 0)
695                 platform_device_unregister(rtc_platform_device);
696
697         return retval;
698 }
699
700 static void __devexit vr41xx_rtc_exit(void)
701 {
702         platform_driver_unregister(&rtc_device_driver);
703
704         platform_device_unregister(rtc_platform_device);
705 }
706
707 module_init(vr41xx_rtc_init);
708 module_exit(vr41xx_rtc_exit);