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