2fc6f093cf6bf017fc1711b8e91880fceaef918a
[openwrt/openwrt.git] / package / kernel / rtc-rv5c386a / src / rtc.c
1 /*
2 * Real Time Clock driver for WL-HDD
3 *
4 * Copyright (C) 2007 Andreas Engel
5 *
6 * Hacked together mostly by copying the relevant code parts from:
7 * drivers/i2c/i2c-bcm5365.c
8 * drivers/i2c/i2c-algo-bit.c
9 * drivers/char/rtc.c
10 *
11 * Note 1:
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()).
15 *
16 * Note 2:
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
19 * in 12h mode.
20 *
21 * Usage:
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
25 * this format.
26 *
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
29 * be used.
30 *
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.
35 *
36 * TODO:
37 * - add a /proc/driver/rtc interface?
38 * - make the battery failure bit available through the /proc interface?
39 *
40 * $Id: rtc.c 7 2007-05-25 19:37:01Z ae $
41 */
42
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>
58
59 #include <asm/current.h>
60 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)
61 #include <asm/system.h>
62 #endif
63
64 #include <bcm47xx.h>
65 #include <bcm47xx_nvram.h>
66
67 #define RTC_IS_OPEN 0x01 /* Means /dev/rtc is in use. */
68
69 /* Can be changed via a module parameter. */
70 static int rtc_debug = 0;
71
72 static unsigned long rtc_status = 0; /* Bitmapped status byte. */
73
74 /* These settings are platform dependents. */
75 unsigned int sda_index = 0;
76 unsigned int scl_index = 0;
77
78 #define I2C_READ_MASK 1
79 #define I2C_WRITE_MASK 0
80
81 #define I2C_ACK 1
82 #define I2C_NAK 0
83
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
90
91 /*
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.
94 */
95 #define ADAP_DELAY 50
96
97 /* Avoid spurious compiler warnings. */
98 #define UNUSED __attribute__((unused))
99
100 MODULE_AUTHOR("Andreas Engel");
101 MODULE_LICENSE("GPL");
102
103 /* Test stolen from switch-adm.c. */
104 module_param(rtc_debug, int, 0);
105
106 static inline void sdalo(void)
107 {
108 gpio_direction_output(sda_index, 1);
109 udelay(ADAP_DELAY);
110 }
111
112 static inline void sdahi(void)
113 {
114 gpio_direction_input(sda_index);
115 udelay(ADAP_DELAY);
116 }
117
118 static inline void scllo(void)
119 {
120 gpio_direction_output(scl_index, 1);
121 udelay(ADAP_DELAY);
122 }
123
124 static inline int getscl(void)
125 {
126 return (gpio_get_value(scl_index));
127 }
128
129 static inline int getsda(void)
130 {
131 return (gpio_get_value(sda_index));
132 }
133
134 /*
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.
140 */
141 static int sclhi(void)
142 {
143 gpio_direction_input(scl_index);
144 udelay(ADAP_DELAY);
145 if (!getscl()) {
146 printk(KERN_ERR "SCL pin should be low\n");
147 return -ETIMEDOUT;
148 }
149 return 0;
150 }
151
152 static void i2c_start(void)
153 {
154 sdalo();
155 scllo();
156 }
157
158 static void i2c_stop(void)
159 {
160 sdalo();
161 sclhi();
162 sdahi();
163 }
164
165 static int i2c_outb(int c)
166 {
167 int i;
168 int ack;
169
170 /* assert: scl is low */
171 for (i = 7; i >= 0; i--) {
172 if (c & ( 1 << i )) {
173 sdahi();
174 } else {
175 sdalo();
176 }
177 if (sclhi() < 0) { /* timed out */
178 sdahi(); /* we don't want to block the net */
179 return -ETIMEDOUT;
180 };
181 scllo();
182 }
183 sdahi();
184 if (sclhi() < 0) {
185 return -ETIMEDOUT;
186 };
187 /* read ack: SDA should be pulled down by slave */
188 ack = getsda() == 0; /* ack: sda is pulled low ->success. */
189 scllo();
190
191 if (rtc_debug)
192 printk(KERN_DEBUG "i2c_outb(0x%02x) -> %s\n",
193 c, ack ? "ACK": "NAK");
194
195 return ack; /* return 1 if device acked */
196 /* assert: scl is low (sda undef) */
197 }
198
199 static int i2c_inb(int ack)
200 {
201 int i;
202 unsigned int indata = 0;
203
204 /* assert: scl is low */
205
206 sdahi();
207 for (i = 0; i < 8; i++) {
208 if (sclhi() < 0) {
209 return -ETIMEDOUT;
210 };
211 indata *= 2;
212 if (getsda())
213 indata |= 0x01;
214 scllo();
215 }
216 if (ack) {
217 sdalo();
218 } else {
219 sdahi();
220 }
221
222 if (sclhi() < 0) {
223 sdahi();
224 return -ETIMEDOUT;
225 }
226 scllo();
227 sdahi();
228
229 if (rtc_debug)
230 printk(KERN_DEBUG "i2c_inb() -> 0x%02x\n", indata);
231
232 /* assert: scl is low */
233 return indata & 0xff;
234 }
235
236 static void i2c_init(void)
237 {
238 /* no gpio_control for EXTIF */
239 // ssb_gpio_control(&ssb, sda_mask | scl_mask, 0);
240
241 gpio_set_value(sda_index, 0);
242 gpio_set_value(scl_index, 0);
243 sdahi();
244 sclhi();
245 }
246
247 static int rtc_open(UNUSED struct inode *inode, UNUSED struct file *filp)
248 {
249 spin_lock_irq(&rtc_lock);
250
251 if (rtc_status & RTC_IS_OPEN) {
252 spin_unlock_irq(&rtc_lock);
253 return -EBUSY;
254 }
255
256 rtc_status |= RTC_IS_OPEN;
257
258 /*
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.
263 */
264 i2c_init();
265
266 spin_unlock_irq(&rtc_lock);
267
268 return 0;
269 }
270
271 static int rtc_release(UNUSED struct inode *inode, UNUSED struct file *filp)
272 {
273 /* No need for locking here. */
274 rtc_status &= ~RTC_IS_OPEN;
275 return 0;
276 }
277
278 static int from_bcd(int bcdnum)
279 {
280 int fac, num = 0;
281
282 for (fac = 1; bcdnum; fac *= 10) {
283 num += (bcdnum % 16) * fac;
284 bcdnum /= 16;
285 }
286
287 return num;
288 }
289
290 static int to_bcd(int decnum)
291 {
292 int fac, num = 0;
293
294 for (fac = 1; decnum; fac *= 16) {
295 num += (decnum % 10) * fac;
296 decnum /= 10;
297 }
298
299 return num;
300 }
301
302 static void get_rtc_time(struct rtc_time *rtc_tm)
303 {
304 int cr2;
305
306 /*
307 * Read date and time from the RTC. We use read method (3).
308 */
309
310 spin_lock_irq(&rtc_lock);
311 i2c_start();
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);
321 i2c_stop();
322 spin_unlock_irq(&rtc_lock);
323
324 if (cr2 & RTC_VDET_MASK) {
325 printk(KERN_WARNING "***RTC BATTERY FAILURE***\n");
326 }
327
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;
332 }
333
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);
340
341 rtc_tm->tm_isdst = -1; /* DST not known */
342 }
343
344 static void set_rtc_time(struct rtc_time *rtc_tm)
345 {
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);
352
353 if (rtc_tm->tm_year >= 0x100) {
354 rtc_tm->tm_year -= 0x100;
355 rtc_tm->tm_mon |= RTC_Y2K_MASK;
356 }
357
358 spin_lock_irq(&rtc_lock);
359 i2c_start();
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);
369 i2c_stop();
370 spin_unlock_irq(&rtc_lock);
371 }
372
373 static ssize_t rtc_write(UNUSED struct file *filp, const char *buf,
374 size_t count, loff_t *ppos)
375 {
376 struct rtc_time rtc_tm;
377 char buffer[23];
378 char *p;
379
380 if (!capable(CAP_SYS_TIME))
381 return -EACCES;
382
383 if (ppos != &filp->f_pos)
384 return -ESPIPE;
385
386 /*
387 * For simplicity, the only acceptable format is:
388 * YYYY:MM:DD:W:HH:MM:SS\n
389 */
390
391 if (count != 22)
392 goto err_out;
393
394 if (copy_from_user(buffer, buf, count))
395 return -EFAULT;
396
397 buffer[sizeof(buffer)-1] = '\0';
398
399 p = &buffer[0];
400
401 rtc_tm.tm_year = simple_strtoul(p, &p, 10);
402 if (*p++ != ':') goto err_out;
403
404 rtc_tm.tm_mon = simple_strtoul(p, &p, 10) - 1;
405 if (*p++ != ':') goto err_out;
406
407 rtc_tm.tm_mday = simple_strtoul(p, &p, 10);
408 if (*p++ != ':') goto err_out;
409
410 rtc_tm.tm_wday = simple_strtoul(p, &p, 10);
411 if (*p++ != ':') goto err_out;
412
413 rtc_tm.tm_hour = simple_strtoul(p, &p, 10);
414 if (*p++ != ':') goto err_out;
415
416 rtc_tm.tm_min = simple_strtoul(p, &p, 10);
417 if (*p++ != ':') goto err_out;
418
419 rtc_tm.tm_sec = simple_strtoul(p, &p, 10);
420 if (*p != '\n') goto err_out;
421
422 rtc_tm.tm_year -= RTC_EPOCH;
423
424 set_rtc_time(&rtc_tm);
425
426 *ppos += count;
427
428 return count;
429
430 err_out:
431 printk(KERN_ERR "invalid format: use YYYY:MM:DD:W:HH:MM:SS\\n\n");
432 return -EINVAL;
433 }
434
435
436 static ssize_t rtc_read(UNUSED struct file *filp, char *buf, size_t count,
437 loff_t *ppos)
438 {
439 char wbuf[23];
440 struct rtc_time tm;
441 ssize_t len;
442
443 if (count == 0 || *ppos != 0)
444 return 0;
445
446 get_rtc_time(&tm);
447
448 len = sprintf(wbuf, "%04d:%02d:%02d:%d:%02d:%02d:%02d\n",
449 tm.tm_year + RTC_EPOCH,
450 tm.tm_mon + 1,
451 tm.tm_mday,
452 tm.tm_wday,
453 tm.tm_hour,
454 tm.tm_min,
455 tm.tm_sec);
456
457 if (len > (ssize_t)count)
458 len = count;
459
460 if (copy_to_user(buf, wbuf, len))
461 return -EFAULT;
462
463 *ppos += len;
464
465 return len;
466 }
467
468 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg)
469 {
470 struct rtc_time rtc_tm;
471
472 switch (cmd) {
473 case RTC_RD_TIME:
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)))
477 return -EFAULT;
478 break;
479
480 case RTC_SET_TIME:
481 if (!capable(CAP_SYS_TIME))
482 return -EACCES;
483
484 if (copy_from_user(&rtc_tm, (struct rtc_time *)arg,
485 sizeof(struct rtc_time)))
486 return -EFAULT;
487
488 set_rtc_time(&rtc_tm);
489 break;
490
491 default:
492 return -ENOTTY;
493 }
494
495 return 0;
496 }
497
498 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
499 {
500 long ret;
501 ret = rtc_do_ioctl(cmd, arg);
502 return ret;
503 }
504
505 static const struct file_operations rtc_fops = {
506 .owner = THIS_MODULE,
507 .llseek = no_llseek,
508 .read = rtc_read,
509 .write = rtc_write,
510 .unlocked_ioctl = rtc_ioctl,
511 .open = rtc_open,
512 .release = rtc_release,
513 };
514
515 static struct miscdevice rtc_dev = {
516 .minor = RTC_MINOR,
517 .name = "rtc",
518 .fops = &rtc_fops,
519 };
520
521 /* Savagely ripped from diag.c. */
522 static inline int startswith (char *source, char *cmp)
523 {
524 return !strncmp(source, cmp, strlen(cmp));
525 }
526
527 static void platform_detect(void)
528 {
529 char buf[20];
530 int et0phyaddr, et1phyaddr;
531
532 /* Based on "model_no". */
533 if (bcm47xx_nvram_getenv("model_no", buf, sizeof(buf)) >= 0) {
534 if (startswith(buf, "WL700")) { /* WL700* */
535 sda_index = 2;
536 scl_index = 5;
537 return;
538 }
539 }
540
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);
545
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) {
549 sda_index = 4;
550 scl_index = 5;
551 return;
552 }
553 }
554 /* not found */
555 }
556
557 static int __init rtc_init(void)
558 {
559 int cr1;
560
561 platform_detect();
562
563 if (sda_index == scl_index) {
564 printk(KERN_ERR "RTC-RV5C386A: unrecognized platform!\n");
565 return -ENODEV;
566 }
567
568 i2c_init();
569
570 /*
571 * Switch RTC to 24h mode
572 */
573 spin_lock_irq(&rtc_lock);
574 i2c_start();
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);
578 i2c_stop();
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);
584 i2c_start();
585 i2c_outb(RTC_I2C_ADDRESS | I2C_WRITE_MASK);
586 i2c_outb(0xE0);
587 i2c_outb(cr1 | RTC_24HOUR_MODE_MASK);
588 i2c_stop();
589 spin_unlock_irq(&rtc_lock);
590 }
591
592 misc_register(&rtc_dev);
593
594 printk(KERN_INFO "RV5C386A Real Time Clock Driver loaded\n");
595
596 return 0;
597 }
598
599 static void __exit rtc_exit (void)
600 {
601 misc_deregister(&rtc_dev);
602 printk(KERN_INFO "Successfully removed RTC RV5C386A driver\n");
603 }
604
605 module_init(rtc_init);
606 module_exit(rtc_exit);
607
608 /*
609 * Local Variables:
610 * indent-tabs-mode:t
611 * c-basic-offset:8
612 * End:
613 */