2 * Real Time Clock driver for WL-HDD
4 * Copyright (C) 2007 Andreas Engel
6 * Hacked together mostly by copying the relevant code parts from:
7 * drivers/i2c/i2c-bcm5365.c
8 * drivers/i2c/i2c-algo-bit.c
12 * This module uses the standard char device (10,135), while the Asus module
13 * rtcdrv.o uses (12,0). So, both can coexist which might be handy during
14 * development (but see the comment in rtc_open()).
17 * You might need to set the clock once after loading the driver the first
18 * time because the driver switches the chip into 24h mode if it is running
22 * For compatibility reasons with the original asus driver, the time can be
23 * read and set via the /dev/rtc device entry. The only accepted data format
24 * is "YYYY:MM:DD:W:HH:MM:SS\n". See OpenWrt wiki for a script which handles
27 * In addition, this driver supports the standard ioctl() calls for setting
28 * and reading the hardware clock, so the ordinary hwclock utility can also
31 * This program is free software; you can redistribute it and/or
32 * modify it under the terms of the GNU General Public License
33 * as published by the Free Software Foundation; either version
34 * 2 of the License, or (at your option) any later version.
37 * - add a /proc/driver/rtc interface?
38 * - make the battery failure bit available through the /proc interface?
40 * $Id: rtc.c 7 2007-05-25 19:37:01Z ae $
43 #include <linux/module.h>
44 #include <linux/kmod.h>
45 #include <linux/kernel.h>
46 #include <linux/types.h>
47 #include <linux/miscdevice.h>
48 #include <linux/ioport.h>
49 #include <linux/fcntl.h>
50 #include <linux/mc146818rtc.h>
51 #include <linux/init.h>
52 #include <linux/spinlock.h>
53 #include <linux/rtc.h>
54 #include <linux/delay.h>
55 #include <linux/version.h>
56 #include <linux/gpio.h>
57 #include <linux/uaccess.h>
59 #include <asm/current.h>
60 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)
61 #include <asm/system.h>
65 #include <linux/bcm47xx_nvram.h>
67 #define RTC_IS_OPEN 0x01 /* Means /dev/rtc is in use. */
69 /* Can be changed via a module parameter. */
70 static int rtc_debug
= 0;
72 static unsigned long rtc_status
= 0; /* Bitmapped status byte. */
74 /* These settings are platform dependents. */
75 unsigned int sda_index
= 0;
76 unsigned int scl_index
= 0;
78 #define I2C_READ_MASK 1
79 #define I2C_WRITE_MASK 0
84 #define RTC_EPOCH 1900
85 #define RTC_I2C_ADDRESS (0x32 << 1)
86 #define RTC_24HOUR_MODE_MASK 0x20
87 #define RTC_PM_MASK 0x20
88 #define RTC_VDET_MASK 0x40
89 #define RTC_Y2K_MASK 0x80
92 * Delay in microseconds for generating the pulses on the I2C bus. We use
93 * a rather conservative setting here. See datasheet of the RTC chip.
97 /* Avoid spurious compiler warnings. */
98 #define UNUSED __attribute__((unused))
100 MODULE_AUTHOR("Andreas Engel");
101 MODULE_LICENSE("GPL");
103 /* Test stolen from switch-adm.c. */
104 module_param(rtc_debug
, int, 0);
106 static inline void sdalo(void)
108 gpio_direction_output(sda_index
, 1);
112 static inline void sdahi(void)
114 gpio_direction_input(sda_index
);
118 static inline void scllo(void)
120 gpio_direction_output(scl_index
, 1);
124 static inline int getscl(void)
126 return (gpio_get_value(scl_index
));
129 static inline int getsda(void)
131 return (gpio_get_value(sda_index
));
135 * We shouldn't simply set the SCL pin to high. Like SDA, the SCL line is
136 * bidirectional too. According to the I2C spec, the slave is allowed to
137 * pull down the SCL line to slow down the clock, so we need to check this.
138 * Generally, we'd need a timeout here, but in our case, we just check the
139 * line, assuming the RTC chip behaves well.
141 static int sclhi(void)
143 gpio_direction_input(scl_index
);
146 printk(KERN_ERR
"SCL pin should be low\n");
152 static void i2c_start(void)
158 static void i2c_stop(void)
165 static int i2c_outb(int c
)
170 /* assert: scl is low */
171 for (i
= 7; i
>= 0; i
--) {
172 if (c
& ( 1 << i
)) {
177 if (sclhi() < 0) { /* timed out */
178 sdahi(); /* we don't want to block the net */
187 /* read ack: SDA should be pulled down by slave */
188 ack
= getsda() == 0; /* ack: sda is pulled low ->success. */
192 printk(KERN_DEBUG
"i2c_outb(0x%02x) -> %s\n",
193 c
, ack
? "ACK": "NAK");
195 return ack
; /* return 1 if device acked */
196 /* assert: scl is low (sda undef) */
199 static int i2c_inb(int ack
)
202 unsigned int indata
= 0;
204 /* assert: scl is low */
207 for (i
= 0; i
< 8; i
++) {
230 printk(KERN_DEBUG
"i2c_inb() -> 0x%02x\n", indata
);
232 /* assert: scl is low */
233 return indata
& 0xff;
236 static void i2c_init(void)
238 /* no gpio_control for EXTIF */
239 // ssb_gpio_control(&ssb, sda_mask | scl_mask, 0);
241 gpio_set_value(sda_index
, 0);
242 gpio_set_value(scl_index
, 0);
247 static int rtc_open(UNUSED
struct inode
*inode
, UNUSED
struct file
*filp
)
249 spin_lock_irq(&rtc_lock
);
251 if (rtc_status
& RTC_IS_OPEN
) {
252 spin_unlock_irq(&rtc_lock
);
256 rtc_status
|= RTC_IS_OPEN
;
259 * The following call is only necessary if we use both this driver and
260 * the proprietary one from asus at the same time (which, b.t.w. only
261 * makes sense during development). Otherwise, each access via the asus
262 * driver will make access via this driver impossible.
266 spin_unlock_irq(&rtc_lock
);
271 static int rtc_release(UNUSED
struct inode
*inode
, UNUSED
struct file
*filp
)
273 /* No need for locking here. */
274 rtc_status
&= ~RTC_IS_OPEN
;
278 static int from_bcd(int bcdnum
)
282 for (fac
= 1; bcdnum
; fac
*= 10) {
283 num
+= (bcdnum
% 16) * fac
;
290 static int to_bcd(int decnum
)
294 for (fac
= 1; decnum
; fac
*= 16) {
295 num
+= (decnum
% 10) * fac
;
302 static void get_rtc_time(struct rtc_time
*rtc_tm
)
307 * Read date and time from the RTC. We use read method (3).
310 spin_lock_irq(&rtc_lock
);
312 i2c_outb(RTC_I2C_ADDRESS
| I2C_READ_MASK
);
313 cr2
= i2c_inb(I2C_ACK
);
314 rtc_tm
->tm_sec
= i2c_inb(I2C_ACK
);
315 rtc_tm
->tm_min
= i2c_inb(I2C_ACK
);
316 rtc_tm
->tm_hour
= i2c_inb(I2C_ACK
);
317 rtc_tm
->tm_wday
= i2c_inb(I2C_ACK
);
318 rtc_tm
->tm_mday
= i2c_inb(I2C_ACK
);
319 rtc_tm
->tm_mon
= i2c_inb(I2C_ACK
);
320 rtc_tm
->tm_year
= i2c_inb(I2C_NAK
);
322 spin_unlock_irq(&rtc_lock
);
324 if (cr2
& RTC_VDET_MASK
) {
325 printk(KERN_WARNING
"***RTC BATTERY FAILURE***\n");
328 /* Handle century bit */
329 if (rtc_tm
->tm_mon
& RTC_Y2K_MASK
) {
330 rtc_tm
->tm_mon
&= ~RTC_Y2K_MASK
;
331 rtc_tm
->tm_year
+= 0x100;
334 rtc_tm
->tm_sec
= from_bcd(rtc_tm
->tm_sec
);
335 rtc_tm
->tm_min
= from_bcd(rtc_tm
->tm_min
);
336 rtc_tm
->tm_hour
= from_bcd(rtc_tm
->tm_hour
);
337 rtc_tm
->tm_mday
= from_bcd(rtc_tm
->tm_mday
);
338 rtc_tm
->tm_mon
= from_bcd(rtc_tm
->tm_mon
) - 1;
339 rtc_tm
->tm_year
= from_bcd(rtc_tm
->tm_year
);
341 rtc_tm
->tm_isdst
= -1; /* DST not known */
344 static void set_rtc_time(struct rtc_time
*rtc_tm
)
346 rtc_tm
->tm_sec
= to_bcd(rtc_tm
->tm_sec
);
347 rtc_tm
->tm_min
= to_bcd(rtc_tm
->tm_min
);
348 rtc_tm
->tm_hour
= to_bcd(rtc_tm
->tm_hour
);
349 rtc_tm
->tm_mday
= to_bcd(rtc_tm
->tm_mday
);
350 rtc_tm
->tm_mon
= to_bcd(rtc_tm
->tm_mon
+ 1);
351 rtc_tm
->tm_year
= to_bcd(rtc_tm
->tm_year
);
353 if (rtc_tm
->tm_year
>= 0x100) {
354 rtc_tm
->tm_year
-= 0x100;
355 rtc_tm
->tm_mon
|= RTC_Y2K_MASK
;
358 spin_lock_irq(&rtc_lock
);
360 i2c_outb(RTC_I2C_ADDRESS
| I2C_WRITE_MASK
);
361 i2c_outb(0x00); /* set starting register to 0 (=seconds) */
362 i2c_outb(rtc_tm
->tm_sec
);
363 i2c_outb(rtc_tm
->tm_min
);
364 i2c_outb(rtc_tm
->tm_hour
);
365 i2c_outb(rtc_tm
->tm_wday
);
366 i2c_outb(rtc_tm
->tm_mday
);
367 i2c_outb(rtc_tm
->tm_mon
);
368 i2c_outb(rtc_tm
->tm_year
);
370 spin_unlock_irq(&rtc_lock
);
373 static ssize_t
rtc_write(UNUSED
struct file
*filp
, const char *buf
,
374 size_t count
, loff_t
*ppos
)
376 struct rtc_time rtc_tm
;
380 if (!capable(CAP_SYS_TIME
))
383 if (ppos
!= &filp
->f_pos
)
387 * For simplicity, the only acceptable format is:
388 * YYYY:MM:DD:W:HH:MM:SS\n
394 if (copy_from_user(buffer
, buf
, count
))
397 buffer
[sizeof(buffer
)-1] = '\0';
401 rtc_tm
.tm_year
= simple_strtoul(p
, &p
, 10);
402 if (*p
++ != ':') goto err_out
;
404 rtc_tm
.tm_mon
= simple_strtoul(p
, &p
, 10) - 1;
405 if (*p
++ != ':') goto err_out
;
407 rtc_tm
.tm_mday
= simple_strtoul(p
, &p
, 10);
408 if (*p
++ != ':') goto err_out
;
410 rtc_tm
.tm_wday
= simple_strtoul(p
, &p
, 10);
411 if (*p
++ != ':') goto err_out
;
413 rtc_tm
.tm_hour
= simple_strtoul(p
, &p
, 10);
414 if (*p
++ != ':') goto err_out
;
416 rtc_tm
.tm_min
= simple_strtoul(p
, &p
, 10);
417 if (*p
++ != ':') goto err_out
;
419 rtc_tm
.tm_sec
= simple_strtoul(p
, &p
, 10);
420 if (*p
!= '\n') goto err_out
;
422 rtc_tm
.tm_year
-= RTC_EPOCH
;
424 set_rtc_time(&rtc_tm
);
431 printk(KERN_ERR
"invalid format: use YYYY:MM:DD:W:HH:MM:SS\\n\n");
436 static ssize_t
rtc_read(UNUSED
struct file
*filp
, char *buf
, size_t count
,
443 if (count
== 0 || *ppos
!= 0)
448 len
= sprintf(wbuf
, "%04d:%02d:%02d:%d:%02d:%02d:%02d\n",
449 tm
.tm_year
+ RTC_EPOCH
,
457 if (len
> (ssize_t
)count
)
460 if (copy_to_user(buf
, wbuf
, len
))
468 static int rtc_do_ioctl(unsigned int cmd
, unsigned long arg
)
470 struct rtc_time rtc_tm
;
474 memset(&rtc_tm
, 0, sizeof(struct rtc_time
));
475 get_rtc_time(&rtc_tm
);
476 if (copy_to_user((void *)arg
, &rtc_tm
, sizeof(rtc_tm
)))
481 if (!capable(CAP_SYS_TIME
))
484 if (copy_from_user(&rtc_tm
, (struct rtc_time
*)arg
,
485 sizeof(struct rtc_time
)))
488 set_rtc_time(&rtc_tm
);
498 static long rtc_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
501 ret
= rtc_do_ioctl(cmd
, arg
);
505 static const struct file_operations rtc_fops
= {
506 .owner
= THIS_MODULE
,
510 .unlocked_ioctl
= rtc_ioctl
,
512 .release
= rtc_release
,
515 static struct miscdevice rtc_dev
= {
521 /* Savagely ripped from diag.c. */
522 static inline int startswith (char *source
, char *cmp
)
524 return !strncmp(source
, cmp
, strlen(cmp
));
527 static void platform_detect(void)
530 int et0phyaddr
, et1phyaddr
;
532 /* Based on "model_no". */
533 if (bcm47xx_nvram_getenv("model_no", buf
, sizeof(buf
)) >= 0) {
534 if (startswith(buf
, "WL700")) { /* WL700* */
541 if (bcm47xx_nvram_getenv("et0phyaddr", buf
, sizeof(buf
)) >= 0 )
542 et0phyaddr
= simple_strtoul(buf
, NULL
, 0);
543 if (bcm47xx_nvram_getenv("et1phyaddr", buf
, sizeof(buf
)) >= 0 )
544 et1phyaddr
= simple_strtoul(buf
, NULL
, 0);
546 if (bcm47xx_nvram_getenv("hardware_version", buf
, sizeof(buf
)) >= 0) {
547 /* Either WL-300g or WL-HDD, do more extensive checks */
548 if (startswith(buf
, "WL300-") && et0phyaddr
== 0 && et1phyaddr
== 1) {
557 static int __init
rtc_init(void)
563 if (sda_index
== scl_index
) {
564 printk(KERN_ERR
"RTC-RV5C386A: unrecognized platform!\n");
571 * Switch RTC to 24h mode
573 spin_lock_irq(&rtc_lock
);
575 i2c_outb(RTC_I2C_ADDRESS
| I2C_WRITE_MASK
);
576 i2c_outb(0xE4); /* start at address 0xE, transmission mode 4 */
577 cr1
= i2c_inb(I2C_NAK
);
579 spin_unlock_irq(&rtc_lock
);
580 if ((cr1
& RTC_24HOUR_MODE_MASK
) == 0) {
581 /* RTC is running in 12h mode */
582 printk(KERN_INFO
"rtc.o: switching to 24h mode\n");
583 spin_lock_irq(&rtc_lock
);
585 i2c_outb(RTC_I2C_ADDRESS
| I2C_WRITE_MASK
);
587 i2c_outb(cr1
| RTC_24HOUR_MODE_MASK
);
589 spin_unlock_irq(&rtc_lock
);
592 misc_register(&rtc_dev
);
594 printk(KERN_INFO
"RV5C386A Real Time Clock Driver loaded\n");
599 static void __exit
rtc_exit (void)
601 misc_deregister(&rtc_dev
);
602 printk(KERN_INFO
"Successfully removed RTC RV5C386A driver\n");
605 module_init(rtc_init
);
606 module_exit(rtc_exit
);