2 * linux/drivers/acorn/char/i2c.c
4 * Copyright (C) 2000 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * ARM IOC/IOMD i2c driver.
12 * On Acorn machines, the following i2c devices are on the bus:
13 * - PCF8583 real time clock & static RAM
15 #include <linux/capability.h>
16 #include <linux/init.h>
17 #include <linux/time.h>
18 #include <linux/miscdevice.h>
19 #include <linux/rtc.h>
20 #include <linux/i2c.h>
21 #include <linux/i2c-algo-bit.h>
24 #include <asm/hardware.h>
26 #include <asm/hardware/ioc.h>
27 #include <asm/system.h>
28 #include <asm/uaccess.h>
32 extern int (*set_rtc
)(void);
34 static struct i2c_client
*rtc_client
;
35 static const unsigned char days_in_mon
[] =
36 { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
38 #define CMOS_CHECKSUM (63)
41 * Acorn machines store the year in the static RAM at
44 #define CMOS_YEAR (64 + 128)
46 static inline int rtc_command(int cmd
, void *data
)
51 ret
= rtc_client
->driver
->command(rtc_client
, cmd
, data
);
57 * Update the century + year bytes in the CMOS RAM, ensuring
58 * that the check byte is correctly adjusted for the change.
60 static int rtc_update_year(unsigned int new_year
)
62 unsigned char yr
[2], chk
;
63 struct mem cmos_year
= { CMOS_YEAR
, sizeof(yr
), yr
};
64 struct mem cmos_check
= { CMOS_CHECKSUM
, 1, &chk
};
67 ret
= rtc_command(MEM_READ
, &cmos_check
);
70 ret
= rtc_command(MEM_READ
, &cmos_year
);
76 yr
[1] = new_year
/ 100;
77 yr
[0] = new_year
% 100;
81 ret
= rtc_command(MEM_WRITE
, &cmos_year
);
83 ret
= rtc_command(MEM_WRITE
, &cmos_check
);
89 * Read the current RTC time and date, and update xtime.
91 static void get_rtc_time(struct rtc_tm
*rtctm
, unsigned int *year
)
93 unsigned char ctrl
, yr
[2];
94 struct mem rtcmem
= { CMOS_YEAR
, sizeof(yr
), yr
};
95 int real_year
, year_offset
;
98 * Ensure that the RTC is running.
100 rtc_command(RTC_GETCTRL
, &ctrl
);
102 unsigned char new_ctrl
= ctrl
& ~0xc0;
104 printk(KERN_WARNING
"RTC: resetting control %02x -> %02x\n",
107 rtc_command(RTC_SETCTRL
, &new_ctrl
);
110 if (rtc_command(RTC_GETDATETIME
, rtctm
) ||
111 rtc_command(MEM_READ
, &rtcmem
))
117 * The RTC year holds the LSB two bits of the current
118 * year, which should reflect the LSB two bits of the
119 * CMOS copy of the year. Any difference indicates
120 * that we have to correct the CMOS version.
122 year_offset
= rtctm
->year_off
- (real_year
& 3);
125 * RTC year wrapped. Adjust it appropriately.
129 *year
= real_year
+ year_offset
+ yr
[1] * 100;
132 static int set_rtc_time(struct rtc_tm
*rtctm
, unsigned int year
)
137 leap
= (!(year
% 4) && (year
% 100)) || !(year
% 400);
139 if (rtctm
->mon
> 12 || rtctm
->mon
== 0 || rtctm
->mday
== 0)
142 if (rtctm
->mday
> (days_in_mon
[rtctm
->mon
] + (rtctm
->mon
== 2 && leap
)))
145 if (rtctm
->hours
>= 24 || rtctm
->mins
>= 60 || rtctm
->secs
>= 60)
149 * The RTC's own 2-bit year must reflect the least
150 * significant two bits of the CMOS year.
152 rtctm
->year_off
= (year
% 100) & 3;
154 ret
= rtc_command(RTC_SETDATETIME
, rtctm
);
156 ret
= rtc_update_year(year
);
162 * Set the RTC time only. Note that
163 * we do not touch the date.
165 static int k_set_rtc_time(void)
167 struct rtc_tm new_rtctm
, old_rtctm
;
168 unsigned long nowtime
= xtime
.tv_sec
;
170 if (rtc_command(RTC_GETDATETIME
, &old_rtctm
))
173 new_rtctm
.cs
= xtime
.tv_nsec
/ 10000000;
174 new_rtctm
.secs
= nowtime
% 60; nowtime
/= 60;
175 new_rtctm
.mins
= nowtime
% 60; nowtime
/= 60;
176 new_rtctm
.hours
= nowtime
% 24;
179 * avoid writing when we're going to change the day
180 * of the month. We will retry in the next minute.
181 * This basically means that if the RTC must not drift
182 * by more than 1 minute in 11 minutes.
184 * [ rtc: 1/1/2000 23:58:00, real 2/1/2000 00:01:00,
185 * rtc gets set to 1/1/2000 00:01:00 ]
187 if ((old_rtctm
.hours
== 23 && old_rtctm
.mins
== 59) ||
188 (new_rtctm
.hours
== 23 && new_rtctm
.mins
== 59))
191 return rtc_command(RTC_SETTIME
, &new_rtctm
);
194 static int rtc_ioctl(struct inode
*inode
, struct file
*file
,
195 unsigned int cmd
, unsigned long arg
)
198 struct rtc_time rtctm
;
199 struct rtc_tm rtc_raw
;
207 memset(&rtctm
, 0, sizeof(struct rtc_time
));
208 get_rtc_time(&rtc_raw
, &year
);
209 rtctm
.tm_sec
= rtc_raw
.secs
;
210 rtctm
.tm_min
= rtc_raw
.mins
;
211 rtctm
.tm_hour
= rtc_raw
.hours
;
212 rtctm
.tm_mday
= rtc_raw
.mday
;
213 rtctm
.tm_mon
= rtc_raw
.mon
- 1; /* month starts at 0 */
214 rtctm
.tm_year
= year
- 1900; /* starts at 1900 */
215 return copy_to_user((void *)arg
, &rtctm
, sizeof(rtctm
))
219 if (!capable(CAP_SYS_TIME
))
222 if (copy_from_user(&rtctm
, (void *)arg
, sizeof(rtctm
)))
224 rtc_raw
.secs
= rtctm
.tm_sec
;
225 rtc_raw
.mins
= rtctm
.tm_min
;
226 rtc_raw
.hours
= rtctm
.tm_hour
;
227 rtc_raw
.mday
= rtctm
.tm_mday
;
228 rtc_raw
.mon
= rtctm
.tm_mon
+ 1;
229 year
= rtctm
.tm_year
+ 1900;
230 return set_rtc_time(&rtc_raw
, year
);
234 return put_user(1900, (unsigned long *)arg
);
240 static const struct file_operations rtc_fops
= {
244 static struct miscdevice rtc_dev
= {
250 /* IOC / IOMD i2c driver */
252 #define FORCE_ONES 0xdc
257 * We must preserve all non-i2c output bits in IOC_CONTROL.
258 * Note also that we need to preserve the value of SCL and
259 * SDA outputs as well (which may be different from the
260 * values read back from IOC_CONTROL).
262 static u_int force_ones
;
264 static void ioc_setscl(void *data
, int state
)
266 u_int ioc_control
= ioc_readb(IOC_CONTROL
) & ~(SCL
| SDA
);
267 u_int ones
= force_ones
;
276 ioc_writeb(ioc_control
| ones
, IOC_CONTROL
);
279 static void ioc_setsda(void *data
, int state
)
281 u_int ioc_control
= ioc_readb(IOC_CONTROL
) & ~(SCL
| SDA
);
282 u_int ones
= force_ones
;
291 ioc_writeb(ioc_control
| ones
, IOC_CONTROL
);
294 static int ioc_getscl(void *data
)
296 return (ioc_readb(IOC_CONTROL
) & SCL
) != 0;
299 static int ioc_getsda(void *data
)
301 return (ioc_readb(IOC_CONTROL
) & SDA
) != 0;
304 static struct i2c_algo_bit_data ioc_data
= {
305 .setsda
= ioc_setsda
,
306 .setscl
= ioc_setscl
,
307 .getsda
= ioc_getsda
,
308 .getscl
= ioc_getscl
,
313 static int ioc_client_reg(struct i2c_client
*client
)
315 if (client
->driver
->id
== I2C_DRIVERID_PCF8583
&&
316 client
->addr
== 0x50) {
322 get_rtc_time(&rtctm
, &year
);
324 tv
.tv_nsec
= rtctm
.cs
* 10000000;
325 tv
.tv_sec
= mktime(year
, rtctm
.mon
, rtctm
.mday
,
326 rtctm
.hours
, rtctm
.mins
, rtctm
.secs
);
327 do_settimeofday(&tv
);
328 set_rtc
= k_set_rtc_time
;
334 static int ioc_client_unreg(struct i2c_client
*client
)
336 if (client
== rtc_client
) {
344 static struct i2c_adapter ioc_ops
= {
346 .algo_data
= &ioc_data
,
347 .client_register
= ioc_client_reg
,
348 .client_unregister
= ioc_client_unreg
,
351 static int __init
i2c_ioc_init(void)
355 force_ones
= FORCE_ONES
| SCL
| SDA
;
357 ret
= i2c_bit_add_bus(&ioc_ops
);
360 ret
= misc_register(&rtc_dev
);
362 i2c_del_adapter(&ioc_ops
);
368 __initcall(i2c_ioc_init
);