Root/package/system/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#include <asm/system.h>
61
62#include <bcm47xx.h>
63#include <nvram.h>
64
65#define RTC_IS_OPEN 0x01 /* Means /dev/rtc is in use. */
66
67/* Can be changed via a module parameter. */
68static int rtc_debug = 0;
69
70static unsigned long rtc_status = 0; /* Bitmapped status byte. */
71
72/* These settings are platform dependents. */
73unsigned int sda_index = 0;
74unsigned int scl_index = 0;
75
76#define I2C_READ_MASK 1
77#define I2C_WRITE_MASK 0
78
79#define I2C_ACK 1
80#define I2C_NAK 0
81
82#define RTC_EPOCH 1900
83#define RTC_I2C_ADDRESS (0x32 << 1)
84#define RTC_24HOUR_MODE_MASK 0x20
85#define RTC_PM_MASK 0x20
86#define RTC_VDET_MASK 0x40
87#define RTC_Y2K_MASK 0x80
88
89/*
90 * Delay in microseconds for generating the pulses on the I2C bus. We use
91 * a rather conservative setting here. See datasheet of the RTC chip.
92 */
93#define ADAP_DELAY 50
94
95/* Avoid spurious compiler warnings. */
96#define UNUSED __attribute__((unused))
97
98MODULE_AUTHOR("Andreas Engel");
99MODULE_LICENSE("GPL");
100
101/* Test stolen from switch-adm.c. */
102module_param(rtc_debug, int, 0);
103
104static inline void sdalo(void)
105{
106    gpio_direction_output(sda_index, 1);
107    udelay(ADAP_DELAY);
108}
109
110static inline void sdahi(void)
111{
112    gpio_direction_input(sda_index);
113    udelay(ADAP_DELAY);
114}
115
116static inline void scllo(void)
117{
118   gpio_direction_output(scl_index, 1);
119    udelay(ADAP_DELAY);
120}
121
122static inline int getscl(void)
123{
124    return (gpio_get_value(scl_index));
125}
126
127static inline int getsda(void)
128{
129    return (gpio_get_value(sda_index));
130}
131
132/*
133 * We shouldn't simply set the SCL pin to high. Like SDA, the SCL line is
134 * bidirectional too. According to the I2C spec, the slave is allowed to
135 * pull down the SCL line to slow down the clock, so we need to check this.
136 * Generally, we'd need a timeout here, but in our case, we just check the
137 * line, assuming the RTC chip behaves well.
138 */
139static int sclhi(void)
140{
141    gpio_direction_input(scl_index);
142    udelay(ADAP_DELAY);
143    if (!getscl()) {
144        printk(KERN_ERR "SCL pin should be low\n");
145        return -ETIMEDOUT;
146    }
147    return 0;
148}
149
150static void i2c_start(void)
151{
152    sdalo();
153    scllo();
154}
155
156static void i2c_stop(void)
157{
158    sdalo();
159    sclhi();
160    sdahi();
161}
162
163static int i2c_outb(int c)
164{
165    int i;
166    int ack;
167
168    /* assert: scl is low */
169    for (i = 7; i >= 0; i--) {
170        if (c & ( 1 << i )) {
171            sdahi();
172        } else {
173            sdalo();
174        }
175        if (sclhi() < 0) { /* timed out */
176            sdahi(); /* we don't want to block the net */
177            return -ETIMEDOUT;
178        };
179        scllo();
180    }
181    sdahi();
182    if (sclhi() < 0) {
183        return -ETIMEDOUT;
184    };
185    /* read ack: SDA should be pulled down by slave */
186    ack = getsda() == 0; /* ack: sda is pulled low ->success. */
187    scllo();
188
189    if (rtc_debug)
190        printk(KERN_DEBUG "i2c_outb(0x%02x) -> %s\n",
191               c, ack ? "ACK": "NAK");
192
193    return ack; /* return 1 if device acked */
194    /* assert: scl is low (sda undef) */
195}
196
197static int i2c_inb(int ack)
198{
199    int i;
200    unsigned int indata = 0;
201
202    /* assert: scl is low */
203
204    sdahi();
205    for (i = 0; i < 8; i++) {
206        if (sclhi() < 0) {
207            return -ETIMEDOUT;
208        };
209        indata *= 2;
210        if (getsda())
211            indata |= 0x01;
212        scllo();
213    }
214    if (ack) {
215        sdalo();
216    } else {
217        sdahi();
218    }
219
220    if (sclhi() < 0) {
221        sdahi();
222        return -ETIMEDOUT;
223    }
224    scllo();
225    sdahi();
226
227    if (rtc_debug)
228        printk(KERN_DEBUG "i2c_inb() -> 0x%02x\n", indata);
229
230    /* assert: scl is low */
231    return indata & 0xff;
232}
233
234static void i2c_init(void)
235{
236    /* no gpio_control for EXTIF */
237    // ssb_gpio_control(&ssb, sda_mask | scl_mask, 0);
238
239   gpio_set_value(sda_index, 0);
240   gpio_set_value(scl_index, 0);
241    sdahi();
242    sclhi();
243}
244
245static int rtc_open(UNUSED struct inode *inode, UNUSED struct file *filp)
246{
247    spin_lock_irq(&rtc_lock);
248
249    if (rtc_status & RTC_IS_OPEN) {
250        spin_unlock_irq(&rtc_lock);
251        return -EBUSY;
252    }
253
254    rtc_status |= RTC_IS_OPEN;
255
256    /*
257     * The following call is only necessary if we use both this driver and
258     * the proprietary one from asus at the same time (which, b.t.w. only
259     * makes sense during development). Otherwise, each access via the asus
260     * driver will make access via this driver impossible.
261     */
262    i2c_init();
263
264    spin_unlock_irq(&rtc_lock);
265
266    return 0;
267}
268
269static int rtc_release(UNUSED struct inode *inode, UNUSED struct file *filp)
270{
271    /* No need for locking here. */
272    rtc_status &= ~RTC_IS_OPEN;
273    return 0;
274}
275
276static int from_bcd(int bcdnum)
277{
278    int fac, num = 0;
279
280    for (fac = 1; bcdnum; fac *= 10) {
281        num += (bcdnum % 16) * fac;
282        bcdnum /= 16;
283    }
284
285    return num;
286}
287
288static int to_bcd(int decnum)
289{
290    int fac, num = 0;
291
292    for (fac = 1; decnum; fac *= 16) {
293        num += (decnum % 10) * fac;
294        decnum /= 10;
295    }
296
297    return num;
298}
299
300static void get_rtc_time(struct rtc_time *rtc_tm)
301{
302    int cr2;
303
304    /*
305     * Read date and time from the RTC. We use read method (3).
306     */
307
308    spin_lock_irq(&rtc_lock);
309    i2c_start();
310    i2c_outb(RTC_I2C_ADDRESS | I2C_READ_MASK);
311    cr2 = i2c_inb(I2C_ACK);
312    rtc_tm->tm_sec = i2c_inb(I2C_ACK);
313    rtc_tm->tm_min = i2c_inb(I2C_ACK);
314    rtc_tm->tm_hour = i2c_inb(I2C_ACK);
315    rtc_tm->tm_wday = i2c_inb(I2C_ACK);
316    rtc_tm->tm_mday = i2c_inb(I2C_ACK);
317    rtc_tm->tm_mon = i2c_inb(I2C_ACK);
318    rtc_tm->tm_year = i2c_inb(I2C_NAK);
319    i2c_stop();
320    spin_unlock_irq(&rtc_lock);
321
322    if (cr2 & RTC_VDET_MASK) {
323        printk(KERN_WARNING "***RTC BATTERY FAILURE***\n");
324    }
325
326    /* Handle century bit */
327    if (rtc_tm->tm_mon & RTC_Y2K_MASK) {
328        rtc_tm->tm_mon &= ~RTC_Y2K_MASK;
329        rtc_tm->tm_year += 0x100;
330    }
331
332    rtc_tm->tm_sec = from_bcd(rtc_tm->tm_sec);
333    rtc_tm->tm_min = from_bcd(rtc_tm->tm_min);
334    rtc_tm->tm_hour = from_bcd(rtc_tm->tm_hour);
335    rtc_tm->tm_mday = from_bcd(rtc_tm->tm_mday);
336    rtc_tm->tm_mon = from_bcd(rtc_tm->tm_mon) - 1;
337    rtc_tm->tm_year = from_bcd(rtc_tm->tm_year);
338
339    rtc_tm->tm_isdst = -1; /* DST not known */
340}
341
342static void set_rtc_time(struct rtc_time *rtc_tm)
343{
344    rtc_tm->tm_sec = to_bcd(rtc_tm->tm_sec);
345    rtc_tm->tm_min = to_bcd(rtc_tm->tm_min);
346    rtc_tm->tm_hour = to_bcd(rtc_tm->tm_hour);
347    rtc_tm->tm_mday = to_bcd(rtc_tm->tm_mday);
348    rtc_tm->tm_mon = to_bcd(rtc_tm->tm_mon + 1);
349    rtc_tm->tm_year = to_bcd(rtc_tm->tm_year);
350
351    if (rtc_tm->tm_year >= 0x100) {
352        rtc_tm->tm_year -= 0x100;
353        rtc_tm->tm_mon |= RTC_Y2K_MASK;
354    }
355
356    spin_lock_irq(&rtc_lock);
357    i2c_start();
358    i2c_outb(RTC_I2C_ADDRESS | I2C_WRITE_MASK);
359    i2c_outb(0x00); /* set starting register to 0 (=seconds) */
360    i2c_outb(rtc_tm->tm_sec);
361    i2c_outb(rtc_tm->tm_min);
362    i2c_outb(rtc_tm->tm_hour);
363    i2c_outb(rtc_tm->tm_wday);
364    i2c_outb(rtc_tm->tm_mday);
365    i2c_outb(rtc_tm->tm_mon);
366    i2c_outb(rtc_tm->tm_year);
367    i2c_stop();
368    spin_unlock_irq(&rtc_lock);
369}
370
371static ssize_t rtc_write(UNUSED struct file *filp, const char *buf,
372                         size_t count, loff_t *ppos)
373{
374    struct rtc_time rtc_tm;
375    char buffer[23];
376    char *p;
377
378    if (!capable(CAP_SYS_TIME))
379        return -EACCES;
380
381    if (ppos != &filp->f_pos)
382        return -ESPIPE;
383
384    /*
385     * For simplicity, the only acceptable format is:
386     * YYYY:MM:DD:W:HH:MM:SS\n
387     */
388
389    if (count != 22)
390        goto err_out;
391
392    if (copy_from_user(buffer, buf, count))
393        return -EFAULT;
394
395    buffer[sizeof(buffer)-1] = '\0';
396
397    p = &buffer[0];
398
399    rtc_tm.tm_year = simple_strtoul(p, &p, 10);
400    if (*p++ != ':') goto err_out;
401
402    rtc_tm.tm_mon = simple_strtoul(p, &p, 10) - 1;
403    if (*p++ != ':') goto err_out;
404
405    rtc_tm.tm_mday = simple_strtoul(p, &p, 10);
406    if (*p++ != ':') goto err_out;
407
408    rtc_tm.tm_wday = simple_strtoul(p, &p, 10);
409    if (*p++ != ':') goto err_out;
410
411    rtc_tm.tm_hour = simple_strtoul(p, &p, 10);
412    if (*p++ != ':') goto err_out;
413
414    rtc_tm.tm_min = simple_strtoul(p, &p, 10);
415    if (*p++ != ':') goto err_out;
416
417    rtc_tm.tm_sec = simple_strtoul(p, &p, 10);
418    if (*p != '\n') goto err_out;
419
420    rtc_tm.tm_year -= RTC_EPOCH;
421
422    set_rtc_time(&rtc_tm);
423
424    *ppos += count;
425
426    return count;
427
428 err_out:
429    printk(KERN_ERR "invalid format: use YYYY:MM:DD:W:HH:MM:SS\\n\n");
430    return -EINVAL;
431}
432
433
434static ssize_t rtc_read(UNUSED struct file *filp, char *buf, size_t count,
435                        loff_t *ppos)
436{
437    char wbuf[23];
438    struct rtc_time tm;
439    ssize_t len;
440
441    if (count == 0 || *ppos != 0)
442        return 0;
443
444    get_rtc_time(&tm);
445
446    len = sprintf(wbuf, "%04d:%02d:%02d:%d:%02d:%02d:%02d\n",
447              tm.tm_year + RTC_EPOCH,
448              tm.tm_mon + 1,
449              tm.tm_mday,
450              tm.tm_wday,
451              tm.tm_hour,
452              tm.tm_min,
453              tm.tm_sec);
454
455    if (len > (ssize_t)count)
456        len = count;
457
458    if (copy_to_user(buf, wbuf, len))
459        return -EFAULT;
460
461    *ppos += len;
462
463    return len;
464}
465
466static int rtc_do_ioctl(unsigned int cmd, unsigned long arg)
467{
468    struct rtc_time rtc_tm;
469
470    switch (cmd) {
471        case RTC_RD_TIME:
472            memset(&rtc_tm, 0, sizeof(struct rtc_time));
473            get_rtc_time(&rtc_tm);
474            if (copy_to_user((void *)arg, &rtc_tm, sizeof(rtc_tm)))
475                return -EFAULT;
476            break;
477
478        case RTC_SET_TIME:
479            if (!capable(CAP_SYS_TIME))
480                return -EACCES;
481
482            if (copy_from_user(&rtc_tm, (struct rtc_time *)arg,
483                       sizeof(struct rtc_time)))
484                return -EFAULT;
485
486            set_rtc_time(&rtc_tm);
487            break;
488
489        default:
490            return -ENOTTY;
491    }
492
493    return 0;
494}
495
496static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
497{
498    long ret;
499    ret = rtc_do_ioctl(cmd, arg);
500    return ret;
501}
502
503static const struct file_operations rtc_fops = {
504    .owner = THIS_MODULE,
505    .llseek = no_llseek,
506    .read = rtc_read,
507    .write = rtc_write,
508    .unlocked_ioctl = rtc_ioctl,
509    .open = rtc_open,
510    .release = rtc_release,
511};
512
513static struct miscdevice rtc_dev = {
514    .minor = RTC_MINOR,
515    .name = "rtc",
516    .fops = &rtc_fops,
517};
518
519/* Savagely ripped from diag.c. */
520static inline int startswith (char *source, char *cmp)
521{
522    return !strncmp(source, cmp, strlen(cmp));
523}
524
525static void platform_detect(void)
526{
527    char buf[20];
528    int et0phyaddr, et1phyaddr;
529
530    /* Based on "model_no". */
531    if (nvram_getenv("model_no", buf, sizeof(buf)) >= 0) {
532        if (startswith(buf, "WL700")) { /* WL700* */
533            sda_index = 2;
534            scl_index = 5;
535            return;
536        }
537    }
538
539    if (nvram_getenv("et0phyaddr", buf, sizeof(buf)) >= 0 )
540        et0phyaddr = simple_strtoul(buf, NULL, 0);
541    if (nvram_getenv("et1phyaddr", buf, sizeof(buf)) >= 0 )
542        et1phyaddr = simple_strtoul(buf, NULL, 0);
543
544    if (nvram_getenv("hardware_version", buf, sizeof(buf)) >= 0) {
545        /* Either WL-300g or WL-HDD, do more extensive checks */
546        if (startswith(buf, "WL300-") && et0phyaddr == 0 && et1phyaddr == 1) {
547            sda_index = 4;
548            scl_index = 5;
549            return;
550        }
551    }
552    /* not found */
553}
554
555static int __init rtc_init(void)
556{
557    int cr1;
558
559    platform_detect();
560
561    if (sda_index == scl_index) {
562        printk(KERN_ERR "RTC-RV5C386A: unrecognized platform!\n");
563        return -ENODEV;
564    }
565
566    i2c_init();
567
568    /*
569     * Switch RTC to 24h mode
570     */
571    spin_lock_irq(&rtc_lock);
572    i2c_start();
573    i2c_outb(RTC_I2C_ADDRESS | I2C_WRITE_MASK);
574    i2c_outb(0xE4); /* start at address 0xE, transmission mode 4 */
575    cr1 = i2c_inb(I2C_NAK);
576    i2c_stop();
577    spin_unlock_irq(&rtc_lock);
578    if ((cr1 & RTC_24HOUR_MODE_MASK) == 0) {
579        /* RTC is running in 12h mode */
580        printk(KERN_INFO "rtc.o: switching to 24h mode\n");
581        spin_lock_irq(&rtc_lock);
582        i2c_start();
583        i2c_outb(RTC_I2C_ADDRESS | I2C_WRITE_MASK);
584        i2c_outb(0xE0);
585        i2c_outb(cr1 | RTC_24HOUR_MODE_MASK);
586        i2c_stop();
587        spin_unlock_irq(&rtc_lock);
588    }
589
590    misc_register(&rtc_dev);
591
592    printk(KERN_INFO "RV5C386A Real Time Clock Driver loaded\n");
593
594    return 0;
595}
596
597static void __exit rtc_exit (void)
598{
599    misc_deregister(&rtc_dev);
600    printk(KERN_INFO "Successfully removed RTC RV5C386A driver\n");
601}
602
603module_init(rtc_init);
604module_exit(rtc_exit);
605
606/*
607 * Local Variables:
608 * indent-tabs-mode:t
609 * c-basic-offset:8
610 * End:
611 */
612

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive