diff options
| -rw-r--r-- | arch/cris/Kconfig | 3 | ||||
| -rw-r--r-- | arch/cris/arch-v10/drivers/pcf8563.c | 2 | ||||
| -rw-r--r-- | arch/cris/arch-v10/kernel/signal.c | 2 | ||||
| -rw-r--r-- | arch/cris/arch-v32/drivers/Makefile | 1 | ||||
| -rw-r--r-- | arch/cris/arch-v32/drivers/pcf8563.c | 377 |
5 files changed, 3 insertions, 382 deletions
diff --git a/arch/cris/Kconfig b/arch/cris/Kconfig index 04a7fc5eaf46..617925ddd142 100644 --- a/arch/cris/Kconfig +++ b/arch/cris/Kconfig | |||
| @@ -296,8 +296,7 @@ config ETRAX_RTC | |||
| 296 | choice | 296 | choice |
| 297 | prompt "RTC chip" | 297 | prompt "RTC chip" |
| 298 | depends on ETRAX_RTC | 298 | depends on ETRAX_RTC |
| 299 | default ETRAX_PCF8563 if ETRAX_ARCH_V32 | 299 | default ETRAX_DS1302 |
| 300 | default ETRAX_DS1302 if ETRAX_ARCH_V10 | ||
| 301 | 300 | ||
| 302 | config ETRAX_DS1302 | 301 | config ETRAX_DS1302 |
| 303 | depends on ETRAX_ARCH_V10 | 302 | depends on ETRAX_ARCH_V10 |
diff --git a/arch/cris/arch-v10/drivers/pcf8563.c b/arch/cris/arch-v10/drivers/pcf8563.c index ea69faba9b62..1391b731ad1c 100644 --- a/arch/cris/arch-v10/drivers/pcf8563.c +++ b/arch/cris/arch-v10/drivers/pcf8563.c | |||
| @@ -345,7 +345,7 @@ static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned | |||
| 345 | int ret; | 345 | int ret; |
| 346 | 346 | ||
| 347 | mutex_lock(&pcf8563_mutex); | 347 | mutex_lock(&pcf8563_mutex); |
| 348 | return pcf8563_ioctl(filp, cmd, arg); | 348 | ret = pcf8563_ioctl(filp, cmd, arg); |
| 349 | mutex_unlock(&pcf8563_mutex); | 349 | mutex_unlock(&pcf8563_mutex); |
| 350 | 350 | ||
| 351 | return ret; | 351 | return ret; |
diff --git a/arch/cris/arch-v10/kernel/signal.c b/arch/cris/arch-v10/kernel/signal.c index b6be705c2a3e..e78fe49a9849 100644 --- a/arch/cris/arch-v10/kernel/signal.c +++ b/arch/cris/arch-v10/kernel/signal.c | |||
| @@ -537,7 +537,7 @@ void do_signal(int canrestart, struct pt_regs *regs) | |||
| 537 | RESTART_CRIS_SYS(regs); | 537 | RESTART_CRIS_SYS(regs); |
| 538 | } | 538 | } |
| 539 | if (regs->r10 == -ERESTART_RESTARTBLOCK) { | 539 | if (regs->r10 == -ERESTART_RESTARTBLOCK) { |
| 540 | regs->r10 = __NR_restart_syscall; | 540 | regs->r9 = __NR_restart_syscall; |
| 541 | regs->irp -= 2; | 541 | regs->irp -= 2; |
| 542 | } | 542 | } |
| 543 | } | 543 | } |
diff --git a/arch/cris/arch-v32/drivers/Makefile b/arch/cris/arch-v32/drivers/Makefile index e8c02437edaf..39aa3c117a86 100644 --- a/arch/cris/arch-v32/drivers/Makefile +++ b/arch/cris/arch-v32/drivers/Makefile | |||
| @@ -7,7 +7,6 @@ obj-$(CONFIG_ETRAX_AXISFLASHMAP) += axisflashmap.o | |||
| 7 | obj-$(CONFIG_ETRAXFS) += mach-fs/ | 7 | obj-$(CONFIG_ETRAXFS) += mach-fs/ |
| 8 | obj-$(CONFIG_CRIS_MACH_ARTPEC3) += mach-a3/ | 8 | obj-$(CONFIG_CRIS_MACH_ARTPEC3) += mach-a3/ |
| 9 | obj-$(CONFIG_ETRAX_IOP_FW_LOAD) += iop_fw_load.o | 9 | obj-$(CONFIG_ETRAX_IOP_FW_LOAD) += iop_fw_load.o |
| 10 | obj-$(CONFIG_ETRAX_PCF8563) += pcf8563.o | ||
| 11 | obj-$(CONFIG_ETRAX_I2C) += i2c.o | 10 | obj-$(CONFIG_ETRAX_I2C) += i2c.o |
| 12 | obj-$(CONFIG_ETRAX_SYNCHRONOUS_SERIAL) += sync_serial.o | 11 | obj-$(CONFIG_ETRAX_SYNCHRONOUS_SERIAL) += sync_serial.o |
| 13 | obj-$(CONFIG_PCI) += pci/ | 12 | obj-$(CONFIG_PCI) += pci/ |
diff --git a/arch/cris/arch-v32/drivers/pcf8563.c b/arch/cris/arch-v32/drivers/pcf8563.c deleted file mode 100644 index b6e4fc0aad42..000000000000 --- a/arch/cris/arch-v32/drivers/pcf8563.c +++ /dev/null | |||
| @@ -1,377 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * PCF8563 RTC | ||
| 3 | * | ||
| 4 | * From Phillips' datasheet: | ||
| 5 | * | ||
| 6 | * The PCF8563 is a CMOS real-time clock/calendar optimized for low power | ||
| 7 | * consumption. A programmable clock output, interrupt output and voltage | ||
| 8 | * low detector are also provided. All address and data are transferred | ||
| 9 | * serially via two-line bidirectional I2C-bus. Maximum bus speed is | ||
| 10 | * 400 kbits/s. The built-in word address register is incremented | ||
| 11 | * automatically after each written or read byte. | ||
| 12 | * | ||
| 13 | * Copyright (c) 2002-2007, Axis Communications AB | ||
| 14 | * All rights reserved. | ||
| 15 | * | ||
| 16 | * Author: Tobias Anderberg <tobiasa@axis.com>. | ||
| 17 | * | ||
| 18 | */ | ||
| 19 | |||
| 20 | #include <linux/module.h> | ||
| 21 | #include <linux/kernel.h> | ||
| 22 | #include <linux/types.h> | ||
| 23 | #include <linux/sched.h> | ||
| 24 | #include <linux/init.h> | ||
| 25 | #include <linux/fs.h> | ||
| 26 | #include <linux/ioctl.h> | ||
| 27 | #include <linux/delay.h> | ||
| 28 | #include <linux/bcd.h> | ||
| 29 | #include <linux/mutex.h> | ||
| 30 | |||
| 31 | #include <asm/uaccess.h> | ||
| 32 | #include <asm/system.h> | ||
| 33 | #include <asm/io.h> | ||
| 34 | #include <asm/rtc.h> | ||
| 35 | |||
| 36 | #include "i2c.h" | ||
| 37 | |||
| 38 | #define PCF8563_MAJOR 121 /* Local major number. */ | ||
| 39 | #define DEVICE_NAME "rtc" /* Name which is registered in /proc/devices. */ | ||
| 40 | #define PCF8563_NAME "PCF8563" | ||
| 41 | #define DRIVER_VERSION "$Revision: 1.17 $" | ||
| 42 | |||
| 43 | /* Two simple wrapper macros, saves a few keystrokes. */ | ||
| 44 | #define rtc_read(x) i2c_readreg(RTC_I2C_READ, x) | ||
| 45 | #define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y) | ||
| 46 | |||
| 47 | static DEFINE_MUTEX(pcf8563_mutex); | ||
| 48 | static DEFINE_MUTEX(rtc_lock); /* Protect state etc */ | ||
| 49 | |||
| 50 | static const unsigned char days_in_month[] = | ||
| 51 | { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; | ||
| 52 | |||
| 53 | static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); | ||
| 54 | |||
| 55 | /* Cache VL bit value read at driver init since writing the RTC_SECOND | ||
| 56 | * register clears the VL status. | ||
| 57 | */ | ||
| 58 | static int voltage_low; | ||
| 59 | |||
| 60 | static const struct file_operations pcf8563_fops = { | ||
| 61 | .owner = THIS_MODULE, | ||
| 62 | .unlocked_ioctl = pcf8563_unlocked_ioctl, | ||
| 63 | .llseek = noop_llseek, | ||
| 64 | }; | ||
| 65 | |||
| 66 | unsigned char | ||
| 67 | pcf8563_readreg(int reg) | ||
| 68 | { | ||
| 69 | unsigned char res = rtc_read(reg); | ||
| 70 | |||
| 71 | /* The PCF8563 does not return 0 for unimplemented bits. */ | ||
| 72 | switch (reg) { | ||
| 73 | case RTC_SECONDS: | ||
| 74 | case RTC_MINUTES: | ||
| 75 | res &= 0x7F; | ||
| 76 | break; | ||
| 77 | case RTC_HOURS: | ||
| 78 | case RTC_DAY_OF_MONTH: | ||
| 79 | res &= 0x3F; | ||
| 80 | break; | ||
| 81 | case RTC_WEEKDAY: | ||
| 82 | res &= 0x07; | ||
| 83 | break; | ||
| 84 | case RTC_MONTH: | ||
| 85 | res &= 0x1F; | ||
| 86 | break; | ||
| 87 | case RTC_CONTROL1: | ||
| 88 | res &= 0xA8; | ||
| 89 | break; | ||
| 90 | case RTC_CONTROL2: | ||
| 91 | res &= 0x1F; | ||
| 92 | break; | ||
| 93 | case RTC_CLOCKOUT_FREQ: | ||
| 94 | case RTC_TIMER_CONTROL: | ||
| 95 | res &= 0x83; | ||
| 96 | break; | ||
| 97 | } | ||
| 98 | return res; | ||
| 99 | } | ||
| 100 | |||
| 101 | void | ||
| 102 | pcf8563_writereg(int reg, unsigned char val) | ||
| 103 | { | ||
| 104 | rtc_write(reg, val); | ||
| 105 | } | ||
| 106 | |||
| 107 | void | ||
| 108 | get_rtc_time(struct rtc_time *tm) | ||
| 109 | { | ||
| 110 | tm->tm_sec = rtc_read(RTC_SECONDS); | ||
| 111 | tm->tm_min = rtc_read(RTC_MINUTES); | ||
| 112 | tm->tm_hour = rtc_read(RTC_HOURS); | ||
| 113 | tm->tm_mday = rtc_read(RTC_DAY_OF_MONTH); | ||
| 114 | tm->tm_wday = rtc_read(RTC_WEEKDAY); | ||
| 115 | tm->tm_mon = rtc_read(RTC_MONTH); | ||
| 116 | tm->tm_year = rtc_read(RTC_YEAR); | ||
| 117 | |||
| 118 | if (tm->tm_sec & 0x80) { | ||
| 119 | printk(KERN_ERR "%s: RTC Voltage Low - reliable date/time " | ||
| 120 | "information is no longer guaranteed!\n", PCF8563_NAME); | ||
| 121 | } | ||
| 122 | |||
| 123 | tm->tm_year = bcd2bin(tm->tm_year) + | ||
| 124 | ((tm->tm_mon & 0x80) ? 100 : 0); | ||
| 125 | tm->tm_sec &= 0x7F; | ||
| 126 | tm->tm_min &= 0x7F; | ||
| 127 | tm->tm_hour &= 0x3F; | ||
| 128 | tm->tm_mday &= 0x3F; | ||
| 129 | tm->tm_wday &= 0x07; /* Not coded in BCD. */ | ||
| 130 | tm->tm_mon &= 0x1F; | ||
| 131 | |||
| 132 | tm->tm_sec = bcd2bin(tm->tm_sec); | ||
| 133 | tm->tm_min = bcd2bin(tm->tm_min); | ||
| 134 | tm->tm_hour = bcd2bin(tm->tm_hour); | ||
| 135 | tm->tm_mday = bcd2bin(tm->tm_mday); | ||
| 136 | tm->tm_mon = bcd2bin(tm->tm_mon); | ||
| 137 | tm->tm_mon--; /* Month is 1..12 in RTC but 0..11 in linux */ | ||
| 138 | } | ||
| 139 | |||
| 140 | int __init | ||
| 141 | pcf8563_init(void) | ||
| 142 | { | ||
| 143 | static int res; | ||
| 144 | static int first = 1; | ||
| 145 | |||
| 146 | if (!first) | ||
| 147 | return res; | ||
| 148 | first = 0; | ||
| 149 | |||
| 150 | /* Initiate the i2c protocol. */ | ||
| 151 | res = i2c_init(); | ||
| 152 | if (res < 0) { | ||
| 153 | printk(KERN_CRIT "pcf8563_init: Failed to init i2c.\n"); | ||
| 154 | return res; | ||
| 155 | } | ||
| 156 | |||
| 157 | /* | ||
| 158 | * First of all we need to reset the chip. This is done by | ||
| 159 | * clearing control1, control2 and clk freq and resetting | ||
| 160 | * all alarms. | ||
| 161 | */ | ||
| 162 | if (rtc_write(RTC_CONTROL1, 0x00) < 0) | ||
| 163 | goto err; | ||
| 164 | |||
| 165 | if (rtc_write(RTC_CONTROL2, 0x00) < 0) | ||
| 166 | goto err; | ||
| 167 | |||
| 168 | if (rtc_write(RTC_CLOCKOUT_FREQ, 0x00) < 0) | ||
| 169 | goto err; | ||
| 170 | |||
| 171 | if (rtc_write(RTC_TIMER_CONTROL, 0x03) < 0) | ||
| 172 | goto err; | ||
| 173 | |||
| 174 | /* Reset the alarms. */ | ||
| 175 | if (rtc_write(RTC_MINUTE_ALARM, 0x80) < 0) | ||
| 176 | goto err; | ||
| 177 | |||
| 178 | if (rtc_write(RTC_HOUR_ALARM, 0x80) < 0) | ||
| 179 | goto err; | ||
| 180 | |||
| 181 | if (rtc_write(RTC_DAY_ALARM, 0x80) < 0) | ||
| 182 | goto err; | ||
| 183 | |||
| 184 | if (rtc_write(RTC_WEEKDAY_ALARM, 0x80) < 0) | ||
| 185 | goto err; | ||
| 186 | |||
| 187 | /* Check for low voltage, and warn about it. */ | ||
| 188 | if (rtc_read(RTC_SECONDS) & 0x80) { | ||
| 189 | voltage_low = 1; | ||
| 190 | printk(KERN_WARNING "%s: RTC Voltage Low - reliable " | ||
| 191 | "date/time information is no longer guaranteed!\n", | ||
| 192 | PCF8563_NAME); | ||
| 193 | } | ||
| 194 | |||
| 195 | return res; | ||
| 196 | |||
| 197 | err: | ||
| 198 | printk(KERN_INFO "%s: Error initializing chip.\n", PCF8563_NAME); | ||
| 199 | res = -1; | ||
| 200 | return res; | ||
| 201 | } | ||
| 202 | |||
| 203 | void __exit | ||
| 204 | pcf8563_exit(void) | ||
| 205 | { | ||
| 206 | unregister_chrdev(PCF8563_MAJOR, DEVICE_NAME); | ||
| 207 | } | ||
| 208 | |||
| 209 | /* | ||
| 210 | * ioctl calls for this driver. Why return -ENOTTY upon error? Because | ||
| 211 | * POSIX says so! | ||
| 212 | */ | ||
| 213 | static int pcf8563_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | ||
| 214 | { | ||
| 215 | /* Some sanity checks. */ | ||
| 216 | if (_IOC_TYPE(cmd) != RTC_MAGIC) | ||
| 217 | return -ENOTTY; | ||
| 218 | |||
| 219 | if (_IOC_NR(cmd) > RTC_MAX_IOCTL) | ||
| 220 | return -ENOTTY; | ||
| 221 | |||
| 222 | switch (cmd) { | ||
| 223 | case RTC_RD_TIME: | ||
| 224 | { | ||
| 225 | struct rtc_time tm; | ||
| 226 | |||
| 227 | mutex_lock(&rtc_lock); | ||
| 228 | memset(&tm, 0, sizeof tm); | ||
| 229 | get_rtc_time(&tm); | ||
| 230 | |||
| 231 | if (copy_to_user((struct rtc_time *) arg, &tm, | ||
| 232 | sizeof tm)) { | ||
| 233 | mutex_unlock(&rtc_lock); | ||
| 234 | return -EFAULT; | ||
| 235 | } | ||
| 236 | |||
| 237 | mutex_unlock(&rtc_lock); | ||
| 238 | |||
| 239 | return 0; | ||
| 240 | } | ||
| 241 | case RTC_SET_TIME: | ||
| 242 | { | ||
| 243 | int leap; | ||
| 244 | int year; | ||
| 245 | int century; | ||
| 246 | struct rtc_time tm; | ||
| 247 | |||
| 248 | memset(&tm, 0, sizeof tm); | ||
| 249 | if (!capable(CAP_SYS_TIME)) | ||
| 250 | return -EPERM; | ||
| 251 | |||
| 252 | if (copy_from_user(&tm, (struct rtc_time *) arg, | ||
| 253 | sizeof tm)) | ||
| 254 | return -EFAULT; | ||
| 255 | |||
| 256 | /* Convert from struct tm to struct rtc_time. */ | ||
| 257 | tm.tm_year += 1900; | ||
| 258 | tm.tm_mon += 1; | ||
| 259 | |||
| 260 | /* | ||
| 261 | * Check if tm.tm_year is a leap year. A year is a leap | ||
| 262 | * year if it is divisible by 4 but not 100, except | ||
| 263 | * that years divisible by 400 _are_ leap years. | ||
| 264 | */ | ||
| 265 | year = tm.tm_year; | ||
| 266 | leap = (tm.tm_mon == 2) && | ||
| 267 | ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0); | ||
| 268 | |||
| 269 | /* Perform some sanity checks. */ | ||
| 270 | if ((tm.tm_year < 1970) || | ||
| 271 | (tm.tm_mon > 12) || | ||
| 272 | (tm.tm_mday == 0) || | ||
| 273 | (tm.tm_mday > days_in_month[tm.tm_mon] + leap) || | ||
| 274 | (tm.tm_wday >= 7) || | ||
| 275 | (tm.tm_hour >= 24) || | ||
| 276 | (tm.tm_min >= 60) || | ||
| 277 | (tm.tm_sec >= 60)) | ||
| 278 | return -EINVAL; | ||
| 279 | |||
| 280 | century = (tm.tm_year >= 2000) ? 0x80 : 0; | ||
| 281 | tm.tm_year = tm.tm_year % 100; | ||
| 282 | |||
| 283 | tm.tm_year = bin2bcd(tm.tm_year); | ||
| 284 | tm.tm_mon = bin2bcd(tm.tm_mon); | ||
| 285 | tm.tm_mday = bin2bcd(tm.tm_mday); | ||
| 286 | tm.tm_hour = bin2bcd(tm.tm_hour); | ||
| 287 | tm.tm_min = bin2bcd(tm.tm_min); | ||
| 288 | tm.tm_sec = bin2bcd(tm.tm_sec); | ||
| 289 | tm.tm_mon |= century; | ||
| 290 | |||
| 291 | mutex_lock(&rtc_lock); | ||
| 292 | |||
| 293 | rtc_write(RTC_YEAR, tm.tm_year); | ||
| 294 | rtc_write(RTC_MONTH, tm.tm_mon); | ||
| 295 | rtc_write(RTC_WEEKDAY, tm.tm_wday); /* Not coded in BCD. */ | ||
| 296 | rtc_write(RTC_DAY_OF_MONTH, tm.tm_mday); | ||
| 297 | rtc_write(RTC_HOURS, tm.tm_hour); | ||
| 298 | rtc_write(RTC_MINUTES, tm.tm_min); | ||
| 299 | rtc_write(RTC_SECONDS, tm.tm_sec); | ||
| 300 | |||
| 301 | mutex_unlock(&rtc_lock); | ||
| 302 | |||
| 303 | return 0; | ||
| 304 | } | ||
| 305 | case RTC_VL_READ: | ||
| 306 | if (voltage_low) | ||
| 307 | printk(KERN_ERR "%s: RTC Voltage Low - " | ||
| 308 | "reliable date/time information is no " | ||
| 309 | "longer guaranteed!\n", PCF8563_NAME); | ||
| 310 | |||
| 311 | if (copy_to_user((int *) arg, &voltage_low, sizeof(int))) | ||
| 312 | return -EFAULT; | ||
| 313 | return 0; | ||
| 314 | |||
| 315 | case RTC_VL_CLR: | ||
| 316 | { | ||
| 317 | /* Clear the VL bit in the seconds register in case | ||
| 318 | * the time has not been set already (which would | ||
| 319 | * have cleared it). This does not really matter | ||
| 320 | * because of the cached voltage_low value but do it | ||
| 321 | * anyway for consistency. */ | ||
| 322 | |||
| 323 | int ret = rtc_read(RTC_SECONDS); | ||
| 324 | |||
| 325 | rtc_write(RTC_SECONDS, (ret & 0x7F)); | ||
| 326 | |||
| 327 | /* Clear the cached value. */ | ||
| 328 | voltage_low = 0; | ||
| 329 | |||
| 330 | return 0; | ||
| 331 | } | ||
| 332 | default: | ||
| 333 | return -ENOTTY; | ||
| 334 | } | ||
| 335 | |||
| 336 | return 0; | ||
| 337 | } | ||
| 338 | |||
| 339 | static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | ||
| 340 | { | ||
| 341 | int ret; | ||
| 342 | |||
| 343 | mutex_lock(&pcf8563_mutex); | ||
| 344 | return pcf8563_ioctl(filp, cmd, arg); | ||
| 345 | mutex_unlock(&pcf8563_mutex); | ||
| 346 | |||
| 347 | return ret; | ||
| 348 | } | ||
| 349 | |||
| 350 | static int __init pcf8563_register(void) | ||
| 351 | { | ||
| 352 | if (pcf8563_init() < 0) { | ||
| 353 | printk(KERN_INFO "%s: Unable to initialize Real-Time Clock " | ||
| 354 | "Driver, %s\n", PCF8563_NAME, DRIVER_VERSION); | ||
| 355 | return -1; | ||
| 356 | } | ||
| 357 | |||
| 358 | if (register_chrdev(PCF8563_MAJOR, DEVICE_NAME, &pcf8563_fops) < 0) { | ||
| 359 | printk(KERN_INFO "%s: Unable to get major numer %d for RTC " | ||
| 360 | "device.\n", PCF8563_NAME, PCF8563_MAJOR); | ||
| 361 | return -1; | ||
| 362 | } | ||
| 363 | |||
| 364 | printk(KERN_INFO "%s Real-Time Clock Driver, %s\n", PCF8563_NAME, | ||
| 365 | DRIVER_VERSION); | ||
| 366 | |||
| 367 | /* Check for low voltage, and warn about it. */ | ||
| 368 | if (voltage_low) { | ||
| 369 | printk(KERN_WARNING "%s: RTC Voltage Low - reliable date/time " | ||
| 370 | "information is no longer guaranteed!\n", PCF8563_NAME); | ||
| 371 | } | ||
| 372 | |||
| 373 | return 0; | ||
| 374 | } | ||
| 375 | |||
| 376 | module_init(pcf8563_register); | ||
| 377 | module_exit(pcf8563_exit); | ||
