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.  */
70static int rtc_debug = 0;
71
72static unsigned long rtc_status = 0;	/* Bitmapped status byte.	*/
73
74/* These settings are platform dependents.  */
75unsigned int sda_index = 0;
76unsigned 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
100MODULE_AUTHOR("Andreas Engel");
101MODULE_LICENSE("GPL");
102
103/* Test stolen from switch-adm.c.  */
104module_param(rtc_debug, int, 0);
105
106static inline void sdalo(void)
107{
108	gpio_direction_output(sda_index, 1);
109	udelay(ADAP_DELAY);
110}
111
112static inline void sdahi(void)
113{
114	gpio_direction_input(sda_index);
115	udelay(ADAP_DELAY);
116}
117
118static inline void scllo(void)
119{
120   gpio_direction_output(scl_index, 1);
121	udelay(ADAP_DELAY);
122}
123
124static inline int getscl(void)
125{
126	return (gpio_get_value(scl_index));
127}
128
129static 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 */
141static 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
152static void i2c_start(void)
153{
154	sdalo();
155	scllo();
156}
157
158static void i2c_stop(void)
159{
160	sdalo();
161	sclhi();
162	sdahi();
163}
164
165static 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
199static 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
236static 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
247static 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
271static 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
278static 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
290static 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
302static 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
344static 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
373static 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
436static 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
468static 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
498static 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
505static 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
515static struct miscdevice rtc_dev = {
516	.minor = RTC_MINOR,
517	.name  = "rtc",
518	.fops  = &rtc_fops,
519};
520
521/* Savagely ripped from diag.c.  */
522static inline int startswith (char *source, char *cmp)
523{
524	return !strncmp(source, cmp, strlen(cmp));
525}
526
527static 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
557static 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
599static void __exit rtc_exit (void)
600{
601	misc_deregister(&rtc_dev);
602	printk(KERN_INFO "Successfully removed RTC RV5C386A driver\n");
603}
604
605module_init(rtc_init);
606module_exit(rtc_exit);
607
608/*
609 * Local Variables:
610 * indent-tabs-mode:t
611 * c-basic-offset:8
612 * End:
613 */
614