diff options
-rw-r--r-- | Documentation/feature-removal-schedule.txt | 7 | ||||
-rw-r--r-- | arch/ppc/platforms/83xx/mpc834x_sys.c | 20 | ||||
-rw-r--r-- | arch/ppc/platforms/85xx/tqm85xx.c | 21 | ||||
-rw-r--r-- | arch/ppc/platforms/katana.c | 21 | ||||
-rw-r--r-- | drivers/i2c/chips/Kconfig | 38 | ||||
-rw-r--r-- | drivers/i2c/chips/Makefile | 3 | ||||
-rw-r--r-- | drivers/i2c/chips/ds1337.c | 410 | ||||
-rw-r--r-- | drivers/i2c/chips/ds1374.c | 267 | ||||
-rw-r--r-- | drivers/i2c/chips/m41t00.c | 413 | ||||
-rw-r--r-- | include/linux/i2c-id.h | 2 | ||||
-rw-r--r-- | include/linux/m41t00.h | 50 |
11 files changed, 0 insertions, 1252 deletions
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt index 9b8291f4c211..2cd16deb7195 100644 --- a/Documentation/feature-removal-schedule.txt +++ b/Documentation/feature-removal-schedule.txt | |||
@@ -266,13 +266,6 @@ Who: Tejun Heo <htejun@gmail.com> | |||
266 | 266 | ||
267 | --------------------------- | 267 | --------------------------- |
268 | 268 | ||
269 | What: Legacy RTC drivers (under drivers/i2c/chips) | ||
270 | When: November 2007 | ||
271 | Why: Obsolete. We have a RTC subsystem with better drivers. | ||
272 | Who: Jean Delvare <khali@linux-fr.org> | ||
273 | |||
274 | --------------------------- | ||
275 | |||
276 | What: iptables SAME target | 269 | What: iptables SAME target |
277 | When: 1.1. 2008 | 270 | When: 1.1. 2008 |
278 | Files: net/ipv4/netfilter/ipt_SAME.c, include/linux/netfilter_ipv4/ipt_SAME.h | 271 | Files: net/ipv4/netfilter/ipt_SAME.c, include/linux/netfilter_ipv4/ipt_SAME.h |
diff --git a/arch/ppc/platforms/83xx/mpc834x_sys.c b/arch/ppc/platforms/83xx/mpc834x_sys.c index b84f8df325c4..cb0a7493ff64 100644 --- a/arch/ppc/platforms/83xx/mpc834x_sys.c +++ b/arch/ppc/platforms/83xx/mpc834x_sys.c | |||
@@ -224,26 +224,6 @@ mpc834x_sys_init_IRQ(void) | |||
224 | ipic_set_default_priority(); | 224 | ipic_set_default_priority(); |
225 | } | 225 | } |
226 | 226 | ||
227 | #if defined(CONFIG_I2C_MPC) && defined(CONFIG_SENSORS_DS1374) | ||
228 | extern ulong ds1374_get_rtc_time(void); | ||
229 | extern int ds1374_set_rtc_time(ulong); | ||
230 | |||
231 | static int __init | ||
232 | mpc834x_rtc_hookup(void) | ||
233 | { | ||
234 | struct timespec tv; | ||
235 | |||
236 | ppc_md.get_rtc_time = ds1374_get_rtc_time; | ||
237 | ppc_md.set_rtc_time = ds1374_set_rtc_time; | ||
238 | |||
239 | tv.tv_nsec = 0; | ||
240 | tv.tv_sec = (ppc_md.get_rtc_time)(); | ||
241 | do_settimeofday(&tv); | ||
242 | |||
243 | return 0; | ||
244 | } | ||
245 | late_initcall(mpc834x_rtc_hookup); | ||
246 | #endif | ||
247 | static __inline__ void | 227 | static __inline__ void |
248 | mpc834x_sys_set_bat(void) | 228 | mpc834x_sys_set_bat(void) |
249 | { | 229 | { |
diff --git a/arch/ppc/platforms/85xx/tqm85xx.c b/arch/ppc/platforms/85xx/tqm85xx.c index 4ee2bd156dc5..27ce389c1224 100644 --- a/arch/ppc/platforms/85xx/tqm85xx.c +++ b/arch/ppc/platforms/85xx/tqm85xx.c | |||
@@ -258,27 +258,6 @@ int tqm85xx_show_cpuinfo(struct seq_file *m) | |||
258 | return 0; | 258 | return 0; |
259 | } | 259 | } |
260 | 260 | ||
261 | #if defined(CONFIG_I2C) && defined(CONFIG_SENSORS_DS1337) | ||
262 | extern ulong ds1337_get_rtc_time(void); | ||
263 | extern int ds1337_set_rtc_time(unsigned long nowtime); | ||
264 | |||
265 | static int __init | ||
266 | tqm85xx_rtc_hookup(void) | ||
267 | { | ||
268 | struct timespec tv; | ||
269 | |||
270 | ppc_md.set_rtc_time = ds1337_set_rtc_time; | ||
271 | ppc_md.get_rtc_time = ds1337_get_rtc_time; | ||
272 | |||
273 | tv.tv_nsec = 0; | ||
274 | tv.tv_sec = (ppc_md.get_rtc_time)(); | ||
275 | do_settimeofday(&tv); | ||
276 | |||
277 | return 0; | ||
278 | } | ||
279 | late_initcall(tqm85xx_rtc_hookup); | ||
280 | #endif | ||
281 | |||
282 | #ifdef CONFIG_PCI | 261 | #ifdef CONFIG_PCI |
283 | /* | 262 | /* |
284 | * interrupt routing | 263 | * interrupt routing |
diff --git a/arch/ppc/platforms/katana.c b/arch/ppc/platforms/katana.c index 52f63e6f0856..fe6e88cdb1cd 100644 --- a/arch/ppc/platforms/katana.c +++ b/arch/ppc/platforms/katana.c | |||
@@ -838,27 +838,6 @@ katana_find_end_of_memory(void) | |||
838 | return bdp->bi_memsize; | 838 | return bdp->bi_memsize; |
839 | } | 839 | } |
840 | 840 | ||
841 | #if defined(CONFIG_I2C_MV64XXX) && defined(CONFIG_SENSORS_M41T00) | ||
842 | extern ulong m41t00_get_rtc_time(void); | ||
843 | extern int m41t00_set_rtc_time(ulong); | ||
844 | |||
845 | static int __init | ||
846 | katana_rtc_hookup(void) | ||
847 | { | ||
848 | struct timespec tv; | ||
849 | |||
850 | ppc_md.get_rtc_time = m41t00_get_rtc_time; | ||
851 | ppc_md.set_rtc_time = m41t00_set_rtc_time; | ||
852 | |||
853 | tv.tv_nsec = 0; | ||
854 | tv.tv_sec = (ppc_md.get_rtc_time)(); | ||
855 | do_settimeofday(&tv); | ||
856 | |||
857 | return 0; | ||
858 | } | ||
859 | late_initcall(katana_rtc_hookup); | ||
860 | #endif | ||
861 | |||
862 | #if defined(CONFIG_SERIAL_TEXT_DEBUG) && defined(CONFIG_SERIAL_MPSC_CONSOLE) | 841 | #if defined(CONFIG_SERIAL_TEXT_DEBUG) && defined(CONFIG_SERIAL_MPSC_CONSOLE) |
863 | static void __init | 842 | static void __init |
864 | katana_map_io(void) | 843 | katana_map_io(void) |
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig index 17702b32eab0..fe3008e59467 100644 --- a/drivers/i2c/chips/Kconfig +++ b/drivers/i2c/chips/Kconfig | |||
@@ -4,32 +4,6 @@ | |||
4 | 4 | ||
5 | menu "Miscellaneous I2C Chip support" | 5 | menu "Miscellaneous I2C Chip support" |
6 | 6 | ||
7 | config SENSORS_DS1337 | ||
8 | tristate "Dallas DS1337 and DS1339 Real Time Clock (DEPRECATED)" | ||
9 | depends on EXPERIMENTAL | ||
10 | help | ||
11 | If you say yes here you get support for Dallas Semiconductor | ||
12 | DS1337 and DS1339 real-time clock chips. | ||
13 | |||
14 | This driver can also be built as a module. If so, the module | ||
15 | will be called ds1337. | ||
16 | |||
17 | This driver is deprecated and will be dropped soon. Use | ||
18 | rtc-ds1307 instead. | ||
19 | |||
20 | config SENSORS_DS1374 | ||
21 | tristate "Dallas DS1374 Real Time Clock (DEPRECATED)" | ||
22 | depends on EXPERIMENTAL | ||
23 | help | ||
24 | If you say yes here you get support for Dallas Semiconductor | ||
25 | DS1374 real-time clock chips. | ||
26 | |||
27 | This driver can also be built as a module. If so, the module | ||
28 | will be called ds1374. | ||
29 | |||
30 | This driver is deprecated and will be dropped soon. Use | ||
31 | rtc-ds1374 instead. | ||
32 | |||
33 | config DS1682 | 7 | config DS1682 |
34 | tristate "Dallas DS1682 Total Elapsed Time Recorder with Alarm" | 8 | tristate "Dallas DS1682 Total Elapsed Time Recorder with Alarm" |
35 | depends on EXPERIMENTAL | 9 | depends on EXPERIMENTAL |
@@ -130,18 +104,6 @@ config TPS65010 | |||
130 | This driver can also be built as a module. If so, the module | 104 | This driver can also be built as a module. If so, the module |
131 | will be called tps65010. | 105 | will be called tps65010. |
132 | 106 | ||
133 | config SENSORS_M41T00 | ||
134 | tristate "ST M41T00 RTC chip (DEPRECATED)" | ||
135 | depends on PPC32 | ||
136 | help | ||
137 | If you say yes here you get support for the ST M41T00 RTC chip. | ||
138 | |||
139 | This driver can also be built as a module. If so, the module | ||
140 | will be called m41t00. | ||
141 | |||
142 | This driver is deprecated and will be dropped soon. Use | ||
143 | rtc-ds1307 or rtc-m41t80 instead. | ||
144 | |||
145 | config SENSORS_MAX6875 | 107 | config SENSORS_MAX6875 |
146 | tristate "Maxim MAX6875 Power supply supervisor" | 108 | tristate "Maxim MAX6875 Power supply supervisor" |
147 | depends on EXPERIMENTAL | 109 | depends on EXPERIMENTAL |
diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile index 50d4734b5038..501f00cea782 100644 --- a/drivers/i2c/chips/Makefile +++ b/drivers/i2c/chips/Makefile | |||
@@ -2,12 +2,9 @@ | |||
2 | # Makefile for miscellaneous I2C chip drivers. | 2 | # Makefile for miscellaneous I2C chip drivers. |
3 | # | 3 | # |
4 | 4 | ||
5 | obj-$(CONFIG_SENSORS_DS1337) += ds1337.o | ||
6 | obj-$(CONFIG_SENSORS_DS1374) += ds1374.o | ||
7 | obj-$(CONFIG_DS1682) += ds1682.o | 5 | obj-$(CONFIG_DS1682) += ds1682.o |
8 | obj-$(CONFIG_SENSORS_EEPROM) += eeprom.o | 6 | obj-$(CONFIG_SENSORS_EEPROM) += eeprom.o |
9 | obj-$(CONFIG_SENSORS_MAX6875) += max6875.o | 7 | obj-$(CONFIG_SENSORS_MAX6875) += max6875.o |
10 | obj-$(CONFIG_SENSORS_M41T00) += m41t00.o | ||
11 | obj-$(CONFIG_SENSORS_PCA9539) += pca9539.o | 8 | obj-$(CONFIG_SENSORS_PCA9539) += pca9539.o |
12 | obj-$(CONFIG_SENSORS_PCF8574) += pcf8574.o | 9 | obj-$(CONFIG_SENSORS_PCF8574) += pcf8574.o |
13 | obj-$(CONFIG_PCF8575) += pcf8575.o | 10 | obj-$(CONFIG_PCF8575) += pcf8575.o |
diff --git a/drivers/i2c/chips/ds1337.c b/drivers/i2c/chips/ds1337.c deleted file mode 100644 index ec17d6b684a2..000000000000 --- a/drivers/i2c/chips/ds1337.c +++ /dev/null | |||
@@ -1,410 +0,0 @@ | |||
1 | /* | ||
2 | * linux/drivers/i2c/chips/ds1337.c | ||
3 | * | ||
4 | * Copyright (C) 2005 James Chapman <jchapman@katalix.com> | ||
5 | * | ||
6 | * based on linux/drivers/acorn/char/pcf8583.c | ||
7 | * Copyright (C) 2000 Russell King | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | * | ||
13 | * Driver for Dallas Semiconductor DS1337 and DS1339 real time clock chip | ||
14 | */ | ||
15 | |||
16 | #include <linux/module.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/slab.h> | ||
19 | #include <linux/i2c.h> | ||
20 | #include <linux/string.h> | ||
21 | #include <linux/rtc.h> /* get the user-level API */ | ||
22 | #include <linux/bcd.h> | ||
23 | #include <linux/list.h> | ||
24 | |||
25 | /* Device registers */ | ||
26 | #define DS1337_REG_HOUR 2 | ||
27 | #define DS1337_REG_DAY 3 | ||
28 | #define DS1337_REG_DATE 4 | ||
29 | #define DS1337_REG_MONTH 5 | ||
30 | #define DS1337_REG_CONTROL 14 | ||
31 | #define DS1337_REG_STATUS 15 | ||
32 | |||
33 | /* FIXME - how do we export these interface constants? */ | ||
34 | #define DS1337_GET_DATE 0 | ||
35 | #define DS1337_SET_DATE 1 | ||
36 | |||
37 | /* | ||
38 | * Functions declaration | ||
39 | */ | ||
40 | static unsigned short normal_i2c[] = { 0x68, I2C_CLIENT_END }; | ||
41 | |||
42 | I2C_CLIENT_INSMOD_1(ds1337); | ||
43 | |||
44 | static int ds1337_attach_adapter(struct i2c_adapter *adapter); | ||
45 | static int ds1337_detect(struct i2c_adapter *adapter, int address, int kind); | ||
46 | static void ds1337_init_client(struct i2c_client *client); | ||
47 | static int ds1337_detach_client(struct i2c_client *client); | ||
48 | static int ds1337_command(struct i2c_client *client, unsigned int cmd, | ||
49 | void *arg); | ||
50 | |||
51 | /* | ||
52 | * Driver data (common to all clients) | ||
53 | */ | ||
54 | static struct i2c_driver ds1337_driver = { | ||
55 | .driver = { | ||
56 | .name = "ds1337", | ||
57 | }, | ||
58 | .attach_adapter = ds1337_attach_adapter, | ||
59 | .detach_client = ds1337_detach_client, | ||
60 | .command = ds1337_command, | ||
61 | }; | ||
62 | |||
63 | /* | ||
64 | * Client data (each client gets its own) | ||
65 | */ | ||
66 | struct ds1337_data { | ||
67 | struct i2c_client client; | ||
68 | struct list_head list; | ||
69 | }; | ||
70 | |||
71 | /* | ||
72 | * Internal variables | ||
73 | */ | ||
74 | static LIST_HEAD(ds1337_clients); | ||
75 | |||
76 | static inline int ds1337_read(struct i2c_client *client, u8 reg, u8 *value) | ||
77 | { | ||
78 | s32 tmp = i2c_smbus_read_byte_data(client, reg); | ||
79 | |||
80 | if (tmp < 0) | ||
81 | return -EIO; | ||
82 | |||
83 | *value = tmp; | ||
84 | |||
85 | return 0; | ||
86 | } | ||
87 | |||
88 | /* | ||
89 | * Chip access functions | ||
90 | */ | ||
91 | static int ds1337_get_datetime(struct i2c_client *client, struct rtc_time *dt) | ||
92 | { | ||
93 | int result; | ||
94 | u8 buf[7]; | ||
95 | u8 val; | ||
96 | struct i2c_msg msg[2]; | ||
97 | u8 offs = 0; | ||
98 | |||
99 | if (!dt) { | ||
100 | dev_dbg(&client->dev, "%s: EINVAL: dt=NULL\n", __FUNCTION__); | ||
101 | return -EINVAL; | ||
102 | } | ||
103 | |||
104 | msg[0].addr = client->addr; | ||
105 | msg[0].flags = 0; | ||
106 | msg[0].len = 1; | ||
107 | msg[0].buf = &offs; | ||
108 | |||
109 | msg[1].addr = client->addr; | ||
110 | msg[1].flags = I2C_M_RD; | ||
111 | msg[1].len = sizeof(buf); | ||
112 | msg[1].buf = &buf[0]; | ||
113 | |||
114 | result = i2c_transfer(client->adapter, msg, 2); | ||
115 | |||
116 | dev_dbg(&client->dev, "%s: [%d] %02x %02x %02x %02x %02x %02x %02x\n", | ||
117 | __FUNCTION__, result, buf[0], buf[1], buf[2], buf[3], | ||
118 | buf[4], buf[5], buf[6]); | ||
119 | |||
120 | if (result == 2) { | ||
121 | dt->tm_sec = BCD2BIN(buf[0]); | ||
122 | dt->tm_min = BCD2BIN(buf[1]); | ||
123 | val = buf[2] & 0x3f; | ||
124 | dt->tm_hour = BCD2BIN(val); | ||
125 | dt->tm_wday = BCD2BIN(buf[3]) - 1; | ||
126 | dt->tm_mday = BCD2BIN(buf[4]); | ||
127 | val = buf[5] & 0x7f; | ||
128 | dt->tm_mon = BCD2BIN(val) - 1; | ||
129 | dt->tm_year = BCD2BIN(buf[6]); | ||
130 | if (buf[5] & 0x80) | ||
131 | dt->tm_year += 100; | ||
132 | |||
133 | dev_dbg(&client->dev, "%s: secs=%d, mins=%d, " | ||
134 | "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n", | ||
135 | __FUNCTION__, dt->tm_sec, dt->tm_min, | ||
136 | dt->tm_hour, dt->tm_mday, | ||
137 | dt->tm_mon, dt->tm_year, dt->tm_wday); | ||
138 | |||
139 | return 0; | ||
140 | } | ||
141 | |||
142 | dev_err(&client->dev, "error reading data! %d\n", result); | ||
143 | return -EIO; | ||
144 | } | ||
145 | |||
146 | static int ds1337_set_datetime(struct i2c_client *client, struct rtc_time *dt) | ||
147 | { | ||
148 | int result; | ||
149 | u8 buf[8]; | ||
150 | u8 val; | ||
151 | struct i2c_msg msg[1]; | ||
152 | |||
153 | if (!dt) { | ||
154 | dev_dbg(&client->dev, "%s: EINVAL: dt=NULL\n", __FUNCTION__); | ||
155 | return -EINVAL; | ||
156 | } | ||
157 | |||
158 | dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, " | ||
159 | "mday=%d, mon=%d, year=%d, wday=%d\n", __FUNCTION__, | ||
160 | dt->tm_sec, dt->tm_min, dt->tm_hour, | ||
161 | dt->tm_mday, dt->tm_mon, dt->tm_year, dt->tm_wday); | ||
162 | |||
163 | buf[0] = 0; /* reg offset */ | ||
164 | buf[1] = BIN2BCD(dt->tm_sec); | ||
165 | buf[2] = BIN2BCD(dt->tm_min); | ||
166 | buf[3] = BIN2BCD(dt->tm_hour); | ||
167 | buf[4] = BIN2BCD(dt->tm_wday + 1); | ||
168 | buf[5] = BIN2BCD(dt->tm_mday); | ||
169 | buf[6] = BIN2BCD(dt->tm_mon + 1); | ||
170 | val = dt->tm_year; | ||
171 | if (val >= 100) { | ||
172 | val -= 100; | ||
173 | buf[6] |= (1 << 7); | ||
174 | } | ||
175 | buf[7] = BIN2BCD(val); | ||
176 | |||
177 | msg[0].addr = client->addr; | ||
178 | msg[0].flags = 0; | ||
179 | msg[0].len = sizeof(buf); | ||
180 | msg[0].buf = &buf[0]; | ||
181 | |||
182 | result = i2c_transfer(client->adapter, msg, 1); | ||
183 | if (result == 1) | ||
184 | return 0; | ||
185 | |||
186 | dev_err(&client->dev, "error writing data! %d\n", result); | ||
187 | return -EIO; | ||
188 | } | ||
189 | |||
190 | static int ds1337_command(struct i2c_client *client, unsigned int cmd, | ||
191 | void *arg) | ||
192 | { | ||
193 | dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd); | ||
194 | |||
195 | switch (cmd) { | ||
196 | case DS1337_GET_DATE: | ||
197 | return ds1337_get_datetime(client, arg); | ||
198 | |||
199 | case DS1337_SET_DATE: | ||
200 | return ds1337_set_datetime(client, arg); | ||
201 | |||
202 | default: | ||
203 | return -EINVAL; | ||
204 | } | ||
205 | } | ||
206 | |||
207 | /* | ||
208 | * Public API for access to specific device. Useful for low-level | ||
209 | * RTC access from kernel code. | ||
210 | */ | ||
211 | int ds1337_do_command(int bus, int cmd, void *arg) | ||
212 | { | ||
213 | struct list_head *walk; | ||
214 | struct list_head *tmp; | ||
215 | struct ds1337_data *data; | ||
216 | |||
217 | list_for_each_safe(walk, tmp, &ds1337_clients) { | ||
218 | data = list_entry(walk, struct ds1337_data, list); | ||
219 | if (data->client.adapter->nr == bus) | ||
220 | return ds1337_command(&data->client, cmd, arg); | ||
221 | } | ||
222 | |||
223 | return -ENODEV; | ||
224 | } | ||
225 | |||
226 | static int ds1337_attach_adapter(struct i2c_adapter *adapter) | ||
227 | { | ||
228 | return i2c_probe(adapter, &addr_data, ds1337_detect); | ||
229 | } | ||
230 | |||
231 | /* | ||
232 | * The following function does more than just detection. If detection | ||
233 | * succeeds, it also registers the new chip. | ||
234 | */ | ||
235 | static int ds1337_detect(struct i2c_adapter *adapter, int address, int kind) | ||
236 | { | ||
237 | struct i2c_client *new_client; | ||
238 | struct ds1337_data *data; | ||
239 | int err = 0; | ||
240 | const char *name = ""; | ||
241 | |||
242 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | | ||
243 | I2C_FUNC_I2C)) | ||
244 | goto exit; | ||
245 | |||
246 | if (!(data = kzalloc(sizeof(struct ds1337_data), GFP_KERNEL))) { | ||
247 | err = -ENOMEM; | ||
248 | goto exit; | ||
249 | } | ||
250 | INIT_LIST_HEAD(&data->list); | ||
251 | |||
252 | /* The common I2C client data is placed right before the | ||
253 | * DS1337-specific data. | ||
254 | */ | ||
255 | new_client = &data->client; | ||
256 | i2c_set_clientdata(new_client, data); | ||
257 | new_client->addr = address; | ||
258 | new_client->adapter = adapter; | ||
259 | new_client->driver = &ds1337_driver; | ||
260 | new_client->flags = 0; | ||
261 | |||
262 | /* | ||
263 | * Now we do the remaining detection. A negative kind means that | ||
264 | * the driver was loaded with no force parameter (default), so we | ||
265 | * must both detect and identify the chip. A zero kind means that | ||
266 | * the driver was loaded with the force parameter, the detection | ||
267 | * step shall be skipped. A positive kind means that the driver | ||
268 | * was loaded with the force parameter and a given kind of chip is | ||
269 | * requested, so both the detection and the identification steps | ||
270 | * are skipped. | ||
271 | * | ||
272 | * For detection, we read registers that are most likely to cause | ||
273 | * detection failure, i.e. those that have more bits with fixed | ||
274 | * or reserved values. | ||
275 | */ | ||
276 | |||
277 | /* Default to an DS1337 if forced */ | ||
278 | if (kind == 0) | ||
279 | kind = ds1337; | ||
280 | |||
281 | if (kind < 0) { /* detection and identification */ | ||
282 | u8 data; | ||
283 | |||
284 | /* Check that status register bits 6-2 are zero */ | ||
285 | if ((ds1337_read(new_client, DS1337_REG_STATUS, &data) < 0) || | ||
286 | (data & 0x7c)) | ||
287 | goto exit_free; | ||
288 | |||
289 | /* Check for a valid day register value */ | ||
290 | if ((ds1337_read(new_client, DS1337_REG_DAY, &data) < 0) || | ||
291 | (data == 0) || (data & 0xf8)) | ||
292 | goto exit_free; | ||
293 | |||
294 | /* Check for a valid date register value */ | ||
295 | if ((ds1337_read(new_client, DS1337_REG_DATE, &data) < 0) || | ||
296 | (data == 0) || (data & 0xc0) || ((data & 0x0f) > 9) || | ||
297 | (data >= 0x32)) | ||
298 | goto exit_free; | ||
299 | |||
300 | /* Check for a valid month register value */ | ||
301 | if ((ds1337_read(new_client, DS1337_REG_MONTH, &data) < 0) || | ||
302 | (data == 0) || (data & 0x60) || ((data & 0x0f) > 9) || | ||
303 | ((data >= 0x13) && (data <= 0x19))) | ||
304 | goto exit_free; | ||
305 | |||
306 | /* Check that control register bits 6-5 are zero */ | ||
307 | if ((ds1337_read(new_client, DS1337_REG_CONTROL, &data) < 0) || | ||
308 | (data & 0x60)) | ||
309 | goto exit_free; | ||
310 | |||
311 | kind = ds1337; | ||
312 | } | ||
313 | |||
314 | if (kind == ds1337) | ||
315 | name = "ds1337"; | ||
316 | |||
317 | /* We can fill in the remaining client fields */ | ||
318 | strlcpy(new_client->name, name, I2C_NAME_SIZE); | ||
319 | |||
320 | /* Tell the I2C layer a new client has arrived */ | ||
321 | if ((err = i2c_attach_client(new_client))) | ||
322 | goto exit_free; | ||
323 | |||
324 | /* Initialize the DS1337 chip */ | ||
325 | ds1337_init_client(new_client); | ||
326 | |||
327 | /* Add client to local list */ | ||
328 | list_add(&data->list, &ds1337_clients); | ||
329 | |||
330 | return 0; | ||
331 | |||
332 | exit_free: | ||
333 | kfree(data); | ||
334 | exit: | ||
335 | return err; | ||
336 | } | ||
337 | |||
338 | static void ds1337_init_client(struct i2c_client *client) | ||
339 | { | ||
340 | u8 status, control; | ||
341 | |||
342 | /* On some boards, the RTC isn't configured by boot firmware. | ||
343 | * Handle that case by starting/configuring the RTC now. | ||
344 | */ | ||
345 | status = i2c_smbus_read_byte_data(client, DS1337_REG_STATUS); | ||
346 | control = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL); | ||
347 | |||
348 | if ((status & 0x80) || (control & 0x80)) { | ||
349 | /* RTC not running */ | ||
350 | u8 buf[1+16]; /* First byte is interpreted as address */ | ||
351 | struct i2c_msg msg[1]; | ||
352 | |||
353 | dev_dbg(&client->dev, "%s: RTC not running!\n", __FUNCTION__); | ||
354 | |||
355 | /* Initialize all, including STATUS and CONTROL to zero */ | ||
356 | memset(buf, 0, sizeof(buf)); | ||
357 | |||
358 | /* Write valid values in the date/time registers */ | ||
359 | buf[1+DS1337_REG_DAY] = 1; | ||
360 | buf[1+DS1337_REG_DATE] = 1; | ||
361 | buf[1+DS1337_REG_MONTH] = 1; | ||
362 | |||
363 | msg[0].addr = client->addr; | ||
364 | msg[0].flags = 0; | ||
365 | msg[0].len = sizeof(buf); | ||
366 | msg[0].buf = &buf[0]; | ||
367 | |||
368 | i2c_transfer(client->adapter, msg, 1); | ||
369 | } else { | ||
370 | /* Running: ensure that device is set in 24-hour mode */ | ||
371 | s32 val; | ||
372 | |||
373 | val = i2c_smbus_read_byte_data(client, DS1337_REG_HOUR); | ||
374 | if ((val >= 0) && (val & (1 << 6))) | ||
375 | i2c_smbus_write_byte_data(client, DS1337_REG_HOUR, | ||
376 | val & 0x3f); | ||
377 | } | ||
378 | } | ||
379 | |||
380 | static int ds1337_detach_client(struct i2c_client *client) | ||
381 | { | ||
382 | int err; | ||
383 | struct ds1337_data *data = i2c_get_clientdata(client); | ||
384 | |||
385 | if ((err = i2c_detach_client(client))) | ||
386 | return err; | ||
387 | |||
388 | list_del(&data->list); | ||
389 | kfree(data); | ||
390 | return 0; | ||
391 | } | ||
392 | |||
393 | static int __init ds1337_init(void) | ||
394 | { | ||
395 | return i2c_add_driver(&ds1337_driver); | ||
396 | } | ||
397 | |||
398 | static void __exit ds1337_exit(void) | ||
399 | { | ||
400 | i2c_del_driver(&ds1337_driver); | ||
401 | } | ||
402 | |||
403 | MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); | ||
404 | MODULE_DESCRIPTION("DS1337 RTC driver"); | ||
405 | MODULE_LICENSE("GPL"); | ||
406 | |||
407 | EXPORT_SYMBOL_GPL(ds1337_do_command); | ||
408 | |||
409 | module_init(ds1337_init); | ||
410 | module_exit(ds1337_exit); | ||
diff --git a/drivers/i2c/chips/ds1374.c b/drivers/i2c/chips/ds1374.c deleted file mode 100644 index 8a2ff0c114d9..000000000000 --- a/drivers/i2c/chips/ds1374.c +++ /dev/null | |||
@@ -1,267 +0,0 @@ | |||
1 | /* | ||
2 | * drivers/i2c/chips/ds1374.c | ||
3 | * | ||
4 | * I2C client/driver for the Maxim/Dallas DS1374 Real-Time Clock | ||
5 | * | ||
6 | * Author: Randy Vinson <rvinson@mvista.com> | ||
7 | * | ||
8 | * Based on the m41t00.c by Mark Greer <mgreer@mvista.com> | ||
9 | * | ||
10 | * 2005 (c) MontaVista Software, Inc. This file is licensed under | ||
11 | * the terms of the GNU General Public License version 2. This program | ||
12 | * is licensed "as is" without any warranty of any kind, whether express | ||
13 | * or implied. | ||
14 | */ | ||
15 | /* | ||
16 | * This i2c client/driver wedges between the drivers/char/genrtc.c RTC | ||
17 | * interface and the SMBus interface of the i2c subsystem. | ||
18 | * It would be more efficient to use i2c msgs/i2c_transfer directly but, as | ||
19 | * recommened in .../Documentation/i2c/writing-clients section | ||
20 | * "Sending and receiving", using SMBus level communication is preferred. | ||
21 | */ | ||
22 | |||
23 | #include <linux/kernel.h> | ||
24 | #include <linux/module.h> | ||
25 | #include <linux/interrupt.h> | ||
26 | #include <linux/i2c.h> | ||
27 | #include <linux/rtc.h> | ||
28 | #include <linux/bcd.h> | ||
29 | #include <linux/mutex.h> | ||
30 | #include <linux/workqueue.h> | ||
31 | |||
32 | #define DS1374_REG_TOD0 0x00 | ||
33 | #define DS1374_REG_TOD1 0x01 | ||
34 | #define DS1374_REG_TOD2 0x02 | ||
35 | #define DS1374_REG_TOD3 0x03 | ||
36 | #define DS1374_REG_WDALM0 0x04 | ||
37 | #define DS1374_REG_WDALM1 0x05 | ||
38 | #define DS1374_REG_WDALM2 0x06 | ||
39 | #define DS1374_REG_CR 0x07 | ||
40 | #define DS1374_REG_SR 0x08 | ||
41 | #define DS1374_REG_SR_OSF 0x80 | ||
42 | #define DS1374_REG_TCR 0x09 | ||
43 | |||
44 | #define DS1374_DRV_NAME "ds1374" | ||
45 | |||
46 | static DEFINE_MUTEX(ds1374_mutex); | ||
47 | |||
48 | static struct i2c_driver ds1374_driver; | ||
49 | static struct i2c_client *save_client; | ||
50 | |||
51 | static unsigned short ignore[] = { I2C_CLIENT_END }; | ||
52 | static unsigned short normal_addr[] = { 0x68, I2C_CLIENT_END }; | ||
53 | |||
54 | static struct i2c_client_address_data addr_data = { | ||
55 | .normal_i2c = normal_addr, | ||
56 | .probe = ignore, | ||
57 | .ignore = ignore, | ||
58 | }; | ||
59 | |||
60 | static ulong ds1374_read_rtc(void) | ||
61 | { | ||
62 | ulong time = 0; | ||
63 | int reg = DS1374_REG_WDALM0; | ||
64 | |||
65 | while (reg--) { | ||
66 | s32 tmp; | ||
67 | if ((tmp = i2c_smbus_read_byte_data(save_client, reg)) < 0) { | ||
68 | dev_warn(&save_client->dev, | ||
69 | "can't read from rtc chip\n"); | ||
70 | return 0; | ||
71 | } | ||
72 | time = (time << 8) | (tmp & 0xff); | ||
73 | } | ||
74 | return time; | ||
75 | } | ||
76 | |||
77 | static void ds1374_write_rtc(ulong time) | ||
78 | { | ||
79 | int reg; | ||
80 | |||
81 | for (reg = DS1374_REG_TOD0; reg < DS1374_REG_WDALM0; reg++) { | ||
82 | if (i2c_smbus_write_byte_data(save_client, reg, time & 0xff) | ||
83 | < 0) { | ||
84 | dev_warn(&save_client->dev, | ||
85 | "can't write to rtc chip\n"); | ||
86 | break; | ||
87 | } | ||
88 | time = time >> 8; | ||
89 | } | ||
90 | } | ||
91 | |||
92 | static void ds1374_check_rtc_status(void) | ||
93 | { | ||
94 | s32 tmp; | ||
95 | |||
96 | tmp = i2c_smbus_read_byte_data(save_client, DS1374_REG_SR); | ||
97 | if (tmp < 0) { | ||
98 | dev_warn(&save_client->dev, | ||
99 | "can't read status from rtc chip\n"); | ||
100 | return; | ||
101 | } | ||
102 | if (tmp & DS1374_REG_SR_OSF) { | ||
103 | dev_warn(&save_client->dev, | ||
104 | "oscillator discontinuity flagged, time unreliable\n"); | ||
105 | tmp &= ~DS1374_REG_SR_OSF; | ||
106 | tmp = i2c_smbus_write_byte_data(save_client, DS1374_REG_SR, | ||
107 | tmp & 0xff); | ||
108 | if (tmp < 0) | ||
109 | dev_warn(&save_client->dev, | ||
110 | "can't clear discontinuity notification\n"); | ||
111 | } | ||
112 | } | ||
113 | |||
114 | ulong ds1374_get_rtc_time(void) | ||
115 | { | ||
116 | ulong t1, t2; | ||
117 | int limit = 10; /* arbitrary retry limit */ | ||
118 | |||
119 | mutex_lock(&ds1374_mutex); | ||
120 | |||
121 | /* | ||
122 | * Since the reads are being performed one byte at a time using | ||
123 | * the SMBus vs a 4-byte i2c transfer, there is a chance that a | ||
124 | * carry will occur during the read. To detect this, 2 reads are | ||
125 | * performed and compared. | ||
126 | */ | ||
127 | do { | ||
128 | t1 = ds1374_read_rtc(); | ||
129 | t2 = ds1374_read_rtc(); | ||
130 | } while (t1 != t2 && limit--); | ||
131 | |||
132 | mutex_unlock(&ds1374_mutex); | ||
133 | |||
134 | if (t1 != t2) { | ||
135 | dev_warn(&save_client->dev, | ||
136 | "can't get consistent time from rtc chip\n"); | ||
137 | t1 = 0; | ||
138 | } | ||
139 | |||
140 | return t1; | ||
141 | } | ||
142 | |||
143 | static ulong new_time; | ||
144 | |||
145 | static void ds1374_set_work(struct work_struct *work) | ||
146 | { | ||
147 | ulong t1, t2; | ||
148 | int limit = 10; /* arbitrary retry limit */ | ||
149 | |||
150 | t1 = new_time; | ||
151 | |||
152 | mutex_lock(&ds1374_mutex); | ||
153 | |||
154 | /* | ||
155 | * Since the writes are being performed one byte at a time using | ||
156 | * the SMBus vs a 4-byte i2c transfer, there is a chance that a | ||
157 | * carry will occur during the write. To detect this, the write | ||
158 | * value is read back and compared. | ||
159 | */ | ||
160 | do { | ||
161 | ds1374_write_rtc(t1); | ||
162 | t2 = ds1374_read_rtc(); | ||
163 | } while (t1 != t2 && limit--); | ||
164 | |||
165 | mutex_unlock(&ds1374_mutex); | ||
166 | |||
167 | if (t1 != t2) | ||
168 | dev_warn(&save_client->dev, | ||
169 | "can't confirm time set from rtc chip\n"); | ||
170 | } | ||
171 | |||
172 | static struct workqueue_struct *ds1374_workqueue; | ||
173 | |||
174 | static DECLARE_WORK(ds1374_work, ds1374_set_work); | ||
175 | |||
176 | int ds1374_set_rtc_time(ulong nowtime) | ||
177 | { | ||
178 | new_time = nowtime; | ||
179 | |||
180 | if (in_interrupt()) | ||
181 | queue_work(ds1374_workqueue, &ds1374_work); | ||
182 | else | ||
183 | ds1374_set_work(NULL); | ||
184 | |||
185 | return 0; | ||
186 | } | ||
187 | |||
188 | /* | ||
189 | ***************************************************************************** | ||
190 | * | ||
191 | * Driver Interface | ||
192 | * | ||
193 | ***************************************************************************** | ||
194 | */ | ||
195 | static int ds1374_probe(struct i2c_adapter *adap, int addr, int kind) | ||
196 | { | ||
197 | struct i2c_client *client; | ||
198 | int rc; | ||
199 | |||
200 | client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); | ||
201 | if (!client) | ||
202 | return -ENOMEM; | ||
203 | |||
204 | strncpy(client->name, DS1374_DRV_NAME, I2C_NAME_SIZE); | ||
205 | client->addr = addr; | ||
206 | client->adapter = adap; | ||
207 | client->driver = &ds1374_driver; | ||
208 | |||
209 | ds1374_workqueue = create_singlethread_workqueue("ds1374"); | ||
210 | if (!ds1374_workqueue) { | ||
211 | kfree(client); | ||
212 | return -ENOMEM; /* most expected reason */ | ||
213 | } | ||
214 | |||
215 | if ((rc = i2c_attach_client(client)) != 0) { | ||
216 | kfree(client); | ||
217 | return rc; | ||
218 | } | ||
219 | |||
220 | save_client = client; | ||
221 | |||
222 | ds1374_check_rtc_status(); | ||
223 | |||
224 | return 0; | ||
225 | } | ||
226 | |||
227 | static int ds1374_attach(struct i2c_adapter *adap) | ||
228 | { | ||
229 | return i2c_probe(adap, &addr_data, ds1374_probe); | ||
230 | } | ||
231 | |||
232 | static int ds1374_detach(struct i2c_client *client) | ||
233 | { | ||
234 | int rc; | ||
235 | |||
236 | if ((rc = i2c_detach_client(client)) == 0) { | ||
237 | kfree(i2c_get_clientdata(client)); | ||
238 | destroy_workqueue(ds1374_workqueue); | ||
239 | } | ||
240 | return rc; | ||
241 | } | ||
242 | |||
243 | static struct i2c_driver ds1374_driver = { | ||
244 | .driver = { | ||
245 | .name = DS1374_DRV_NAME, | ||
246 | }, | ||
247 | .id = I2C_DRIVERID_DS1374, | ||
248 | .attach_adapter = ds1374_attach, | ||
249 | .detach_client = ds1374_detach, | ||
250 | }; | ||
251 | |||
252 | static int __init ds1374_init(void) | ||
253 | { | ||
254 | return i2c_add_driver(&ds1374_driver); | ||
255 | } | ||
256 | |||
257 | static void __exit ds1374_exit(void) | ||
258 | { | ||
259 | i2c_del_driver(&ds1374_driver); | ||
260 | } | ||
261 | |||
262 | module_init(ds1374_init); | ||
263 | module_exit(ds1374_exit); | ||
264 | |||
265 | MODULE_AUTHOR("Randy Vinson <rvinson@mvista.com>"); | ||
266 | MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC I2C Client Driver"); | ||
267 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/i2c/chips/m41t00.c b/drivers/i2c/chips/m41t00.c deleted file mode 100644 index 3fcb646e2073..000000000000 --- a/drivers/i2c/chips/m41t00.c +++ /dev/null | |||
@@ -1,413 +0,0 @@ | |||
1 | /* | ||
2 | * I2C client/driver for the ST M41T00 family of i2c rtc chips. | ||
3 | * | ||
4 | * Author: Mark A. Greer <mgreer@mvista.com> | ||
5 | * | ||
6 | * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under | ||
7 | * the terms of the GNU General Public License version 2. This program | ||
8 | * is licensed "as is" without any warranty of any kind, whether express | ||
9 | * or implied. | ||
10 | */ | ||
11 | /* | ||
12 | * This i2c client/driver wedges between the drivers/char/genrtc.c RTC | ||
13 | * interface and the SMBus interface of the i2c subsystem. | ||
14 | */ | ||
15 | |||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/module.h> | ||
18 | #include <linux/interrupt.h> | ||
19 | #include <linux/i2c.h> | ||
20 | #include <linux/rtc.h> | ||
21 | #include <linux/bcd.h> | ||
22 | #include <linux/workqueue.h> | ||
23 | #include <linux/platform_device.h> | ||
24 | #include <linux/m41t00.h> | ||
25 | #include <asm/time.h> | ||
26 | #include <asm/rtc.h> | ||
27 | |||
28 | static struct i2c_driver m41t00_driver; | ||
29 | static struct i2c_client *save_client; | ||
30 | |||
31 | static unsigned short ignore[] = { I2C_CLIENT_END }; | ||
32 | static unsigned short normal_addr[] = { I2C_CLIENT_END, I2C_CLIENT_END }; | ||
33 | |||
34 | static struct i2c_client_address_data addr_data = { | ||
35 | .normal_i2c = normal_addr, | ||
36 | .probe = ignore, | ||
37 | .ignore = ignore, | ||
38 | }; | ||
39 | |||
40 | struct m41t00_chip_info { | ||
41 | u8 type; | ||
42 | char *name; | ||
43 | u8 read_limit; | ||
44 | u8 sec; /* Offsets for chip regs */ | ||
45 | u8 min; | ||
46 | u8 hour; | ||
47 | u8 day; | ||
48 | u8 mon; | ||
49 | u8 year; | ||
50 | u8 alarm_mon; | ||
51 | u8 alarm_hour; | ||
52 | u8 sqw; | ||
53 | u8 sqw_freq; | ||
54 | }; | ||
55 | |||
56 | static struct m41t00_chip_info m41t00_chip_info_tbl[] = { | ||
57 | { | ||
58 | .type = M41T00_TYPE_M41T00, | ||
59 | .name = "m41t00", | ||
60 | .read_limit = 5, | ||
61 | .sec = 0, | ||
62 | .min = 1, | ||
63 | .hour = 2, | ||
64 | .day = 4, | ||
65 | .mon = 5, | ||
66 | .year = 6, | ||
67 | }, | ||
68 | { | ||
69 | .type = M41T00_TYPE_M41T81, | ||
70 | .name = "m41t81", | ||
71 | .read_limit = 1, | ||
72 | .sec = 1, | ||
73 | .min = 2, | ||
74 | .hour = 3, | ||
75 | .day = 5, | ||
76 | .mon = 6, | ||
77 | .year = 7, | ||
78 | .alarm_mon = 0xa, | ||
79 | .alarm_hour = 0xc, | ||
80 | .sqw = 0x13, | ||
81 | }, | ||
82 | { | ||
83 | .type = M41T00_TYPE_M41T85, | ||
84 | .name = "m41t85", | ||
85 | .read_limit = 1, | ||
86 | .sec = 1, | ||
87 | .min = 2, | ||
88 | .hour = 3, | ||
89 | .day = 5, | ||
90 | .mon = 6, | ||
91 | .year = 7, | ||
92 | .alarm_mon = 0xa, | ||
93 | .alarm_hour = 0xc, | ||
94 | .sqw = 0x13, | ||
95 | }, | ||
96 | }; | ||
97 | static struct m41t00_chip_info *m41t00_chip; | ||
98 | |||
99 | ulong | ||
100 | m41t00_get_rtc_time(void) | ||
101 | { | ||
102 | s32 sec, min, hour, day, mon, year; | ||
103 | s32 sec1, min1, hour1, day1, mon1, year1; | ||
104 | u8 reads = 0; | ||
105 | u8 buf[8], msgbuf[1] = { 0 }; /* offset into rtc's regs */ | ||
106 | struct i2c_msg msgs[] = { | ||
107 | { | ||
108 | .addr = save_client->addr, | ||
109 | .flags = 0, | ||
110 | .len = 1, | ||
111 | .buf = msgbuf, | ||
112 | }, | ||
113 | { | ||
114 | .addr = save_client->addr, | ||
115 | .flags = I2C_M_RD, | ||
116 | .len = 8, | ||
117 | .buf = buf, | ||
118 | }, | ||
119 | }; | ||
120 | |||
121 | sec = min = hour = day = mon = year = 0; | ||
122 | |||
123 | do { | ||
124 | if (i2c_transfer(save_client->adapter, msgs, 2) < 0) | ||
125 | goto read_err; | ||
126 | |||
127 | sec1 = sec; | ||
128 | min1 = min; | ||
129 | hour1 = hour; | ||
130 | day1 = day; | ||
131 | mon1 = mon; | ||
132 | year1 = year; | ||
133 | |||
134 | sec = buf[m41t00_chip->sec] & 0x7f; | ||
135 | min = buf[m41t00_chip->min] & 0x7f; | ||
136 | hour = buf[m41t00_chip->hour] & 0x3f; | ||
137 | day = buf[m41t00_chip->day] & 0x3f; | ||
138 | mon = buf[m41t00_chip->mon] & 0x1f; | ||
139 | year = buf[m41t00_chip->year]; | ||
140 | } while ((++reads < m41t00_chip->read_limit) && ((sec != sec1) | ||
141 | || (min != min1) || (hour != hour1) || (day != day1) | ||
142 | || (mon != mon1) || (year != year1))); | ||
143 | |||
144 | if ((m41t00_chip->read_limit > 1) && ((sec != sec1) || (min != min1) | ||
145 | || (hour != hour1) || (day != day1) || (mon != mon1) | ||
146 | || (year != year1))) | ||
147 | goto read_err; | ||
148 | |||
149 | sec = BCD2BIN(sec); | ||
150 | min = BCD2BIN(min); | ||
151 | hour = BCD2BIN(hour); | ||
152 | day = BCD2BIN(day); | ||
153 | mon = BCD2BIN(mon); | ||
154 | year = BCD2BIN(year); | ||
155 | |||
156 | year += 1900; | ||
157 | if (year < 1970) | ||
158 | year += 100; | ||
159 | |||
160 | return mktime(year, mon, day, hour, min, sec); | ||
161 | |||
162 | read_err: | ||
163 | dev_err(&save_client->dev, "m41t00_get_rtc_time: Read error\n"); | ||
164 | return 0; | ||
165 | } | ||
166 | EXPORT_SYMBOL_GPL(m41t00_get_rtc_time); | ||
167 | |||
168 | static void | ||
169 | m41t00_set(void *arg) | ||
170 | { | ||
171 | struct rtc_time tm; | ||
172 | int nowtime = *(int *)arg; | ||
173 | s32 sec, min, hour, day, mon, year; | ||
174 | u8 wbuf[9], *buf = &wbuf[1], msgbuf[1] = { 0 }; | ||
175 | struct i2c_msg msgs[] = { | ||
176 | { | ||
177 | .addr = save_client->addr, | ||
178 | .flags = 0, | ||
179 | .len = 1, | ||
180 | .buf = msgbuf, | ||
181 | }, | ||
182 | { | ||
183 | .addr = save_client->addr, | ||
184 | .flags = I2C_M_RD, | ||
185 | .len = 8, | ||
186 | .buf = buf, | ||
187 | }, | ||
188 | }; | ||
189 | |||
190 | to_tm(nowtime, &tm); | ||
191 | tm.tm_year = (tm.tm_year - 1900) % 100; | ||
192 | |||
193 | sec = BIN2BCD(tm.tm_sec); | ||
194 | min = BIN2BCD(tm.tm_min); | ||
195 | hour = BIN2BCD(tm.tm_hour); | ||
196 | day = BIN2BCD(tm.tm_mday); | ||
197 | mon = BIN2BCD(tm.tm_mon); | ||
198 | year = BIN2BCD(tm.tm_year); | ||
199 | |||
200 | /* Read reg values into buf[0..7]/wbuf[1..8] */ | ||
201 | if (i2c_transfer(save_client->adapter, msgs, 2) < 0) { | ||
202 | dev_err(&save_client->dev, "m41t00_set: Read error\n"); | ||
203 | return; | ||
204 | } | ||
205 | |||
206 | wbuf[0] = 0; /* offset into rtc's regs */ | ||
207 | buf[m41t00_chip->sec] = (buf[m41t00_chip->sec] & ~0x7f) | (sec & 0x7f); | ||
208 | buf[m41t00_chip->min] = (buf[m41t00_chip->min] & ~0x7f) | (min & 0x7f); | ||
209 | buf[m41t00_chip->hour] = (buf[m41t00_chip->hour] & ~0x3f) | (hour& 0x3f); | ||
210 | buf[m41t00_chip->day] = (buf[m41t00_chip->day] & ~0x3f) | (day & 0x3f); | ||
211 | buf[m41t00_chip->mon] = (buf[m41t00_chip->mon] & ~0x1f) | (mon & 0x1f); | ||
212 | buf[m41t00_chip->year] = year; | ||
213 | |||
214 | if (i2c_master_send(save_client, wbuf, 9) < 0) | ||
215 | dev_err(&save_client->dev, "m41t00_set: Write error\n"); | ||
216 | } | ||
217 | |||
218 | static ulong new_time; | ||
219 | /* well, isn't this API just _lovely_? */ | ||
220 | static void | ||
221 | m41t00_barf(struct work_struct *unusable) | ||
222 | { | ||
223 | m41t00_set(&new_time); | ||
224 | } | ||
225 | |||
226 | static struct workqueue_struct *m41t00_wq; | ||
227 | static DECLARE_WORK(m41t00_work, m41t00_barf); | ||
228 | |||
229 | int | ||
230 | m41t00_set_rtc_time(ulong nowtime) | ||
231 | { | ||
232 | new_time = nowtime; | ||
233 | |||
234 | if (in_interrupt()) | ||
235 | queue_work(m41t00_wq, &m41t00_work); | ||
236 | else | ||
237 | m41t00_set(&new_time); | ||
238 | |||
239 | return 0; | ||
240 | } | ||
241 | EXPORT_SYMBOL_GPL(m41t00_set_rtc_time); | ||
242 | |||
243 | /* | ||
244 | ***************************************************************************** | ||
245 | * | ||
246 | * platform_data Driver Interface | ||
247 | * | ||
248 | ***************************************************************************** | ||
249 | */ | ||
250 | static int __init | ||
251 | m41t00_platform_probe(struct platform_device *pdev) | ||
252 | { | ||
253 | struct m41t00_platform_data *pdata; | ||
254 | int i; | ||
255 | |||
256 | if (pdev && (pdata = pdev->dev.platform_data)) { | ||
257 | normal_addr[0] = pdata->i2c_addr; | ||
258 | |||
259 | for (i=0; i<ARRAY_SIZE(m41t00_chip_info_tbl); i++) | ||
260 | if (m41t00_chip_info_tbl[i].type == pdata->type) { | ||
261 | m41t00_chip = &m41t00_chip_info_tbl[i]; | ||
262 | m41t00_chip->sqw_freq = pdata->sqw_freq; | ||
263 | return 0; | ||
264 | } | ||
265 | } | ||
266 | return -ENODEV; | ||
267 | } | ||
268 | |||
269 | static int __exit | ||
270 | m41t00_platform_remove(struct platform_device *pdev) | ||
271 | { | ||
272 | return 0; | ||
273 | } | ||
274 | |||
275 | static struct platform_driver m41t00_platform_driver = { | ||
276 | .probe = m41t00_platform_probe, | ||
277 | .remove = m41t00_platform_remove, | ||
278 | .driver = { | ||
279 | .owner = THIS_MODULE, | ||
280 | .name = M41T00_DRV_NAME, | ||
281 | }, | ||
282 | }; | ||
283 | |||
284 | /* | ||
285 | ***************************************************************************** | ||
286 | * | ||
287 | * Driver Interface | ||
288 | * | ||
289 | ***************************************************************************** | ||
290 | */ | ||
291 | static int | ||
292 | m41t00_probe(struct i2c_adapter *adap, int addr, int kind) | ||
293 | { | ||
294 | struct i2c_client *client; | ||
295 | int rc; | ||
296 | |||
297 | if (!i2c_check_functionality(adap, I2C_FUNC_I2C | ||
298 | | I2C_FUNC_SMBUS_BYTE_DATA)) | ||
299 | return 0; | ||
300 | |||
301 | client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); | ||
302 | if (!client) | ||
303 | return -ENOMEM; | ||
304 | |||
305 | strlcpy(client->name, m41t00_chip->name, I2C_NAME_SIZE); | ||
306 | client->addr = addr; | ||
307 | client->adapter = adap; | ||
308 | client->driver = &m41t00_driver; | ||
309 | |||
310 | if ((rc = i2c_attach_client(client))) | ||
311 | goto attach_err; | ||
312 | |||
313 | if (m41t00_chip->type != M41T00_TYPE_M41T00) { | ||
314 | /* If asked, disable SQW, set SQW frequency & re-enable */ | ||
315 | if (m41t00_chip->sqw_freq) | ||
316 | if (((rc = i2c_smbus_read_byte_data(client, | ||
317 | m41t00_chip->alarm_mon)) < 0) | ||
318 | || ((rc = i2c_smbus_write_byte_data(client, | ||
319 | m41t00_chip->alarm_mon, rc & ~0x40)) <0) | ||
320 | || ((rc = i2c_smbus_write_byte_data(client, | ||
321 | m41t00_chip->sqw, | ||
322 | m41t00_chip->sqw_freq)) < 0) | ||
323 | || ((rc = i2c_smbus_write_byte_data(client, | ||
324 | m41t00_chip->alarm_mon, rc | 0x40)) <0)) | ||
325 | goto sqw_err; | ||
326 | |||
327 | /* Make sure HT (Halt Update) bit is cleared */ | ||
328 | if ((rc = i2c_smbus_read_byte_data(client, | ||
329 | m41t00_chip->alarm_hour)) < 0) | ||
330 | goto ht_err; | ||
331 | |||
332 | if (rc & 0x40) | ||
333 | if ((rc = i2c_smbus_write_byte_data(client, | ||
334 | m41t00_chip->alarm_hour, rc & ~0x40))<0) | ||
335 | goto ht_err; | ||
336 | } | ||
337 | |||
338 | /* Make sure ST (stop) bit is cleared */ | ||
339 | if ((rc = i2c_smbus_read_byte_data(client, m41t00_chip->sec)) < 0) | ||
340 | goto st_err; | ||
341 | |||
342 | if (rc & 0x80) | ||
343 | if ((rc = i2c_smbus_write_byte_data(client, m41t00_chip->sec, | ||
344 | rc & ~0x80)) < 0) | ||
345 | goto st_err; | ||
346 | |||
347 | m41t00_wq = create_singlethread_workqueue(m41t00_chip->name); | ||
348 | save_client = client; | ||
349 | return 0; | ||
350 | |||
351 | st_err: | ||
352 | dev_err(&client->dev, "m41t00_probe: Can't clear ST bit\n"); | ||
353 | goto attach_err; | ||
354 | ht_err: | ||
355 | dev_err(&client->dev, "m41t00_probe: Can't clear HT bit\n"); | ||
356 | goto attach_err; | ||
357 | sqw_err: | ||
358 | dev_err(&client->dev, "m41t00_probe: Can't set SQW Frequency\n"); | ||
359 | attach_err: | ||
360 | kfree(client); | ||
361 | return rc; | ||
362 | } | ||
363 | |||
364 | static int | ||
365 | m41t00_attach(struct i2c_adapter *adap) | ||
366 | { | ||
367 | return i2c_probe(adap, &addr_data, m41t00_probe); | ||
368 | } | ||
369 | |||
370 | static int | ||
371 | m41t00_detach(struct i2c_client *client) | ||
372 | { | ||
373 | int rc; | ||
374 | |||
375 | if ((rc = i2c_detach_client(client)) == 0) { | ||
376 | kfree(client); | ||
377 | destroy_workqueue(m41t00_wq); | ||
378 | } | ||
379 | return rc; | ||
380 | } | ||
381 | |||
382 | static struct i2c_driver m41t00_driver = { | ||
383 | .driver = { | ||
384 | .name = M41T00_DRV_NAME, | ||
385 | }, | ||
386 | .id = I2C_DRIVERID_STM41T00, | ||
387 | .attach_adapter = m41t00_attach, | ||
388 | .detach_client = m41t00_detach, | ||
389 | }; | ||
390 | |||
391 | static int __init | ||
392 | m41t00_init(void) | ||
393 | { | ||
394 | int rc; | ||
395 | |||
396 | if (!(rc = platform_driver_register(&m41t00_platform_driver))) | ||
397 | rc = i2c_add_driver(&m41t00_driver); | ||
398 | return rc; | ||
399 | } | ||
400 | |||
401 | static void __exit | ||
402 | m41t00_exit(void) | ||
403 | { | ||
404 | i2c_del_driver(&m41t00_driver); | ||
405 | platform_driver_unregister(&m41t00_platform_driver); | ||
406 | } | ||
407 | |||
408 | module_init(m41t00_init); | ||
409 | module_exit(m41t00_exit); | ||
410 | |||
411 | MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>"); | ||
412 | MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver"); | ||
413 | MODULE_LICENSE("GPL"); | ||
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h index c7a51a196f51..10c8edd7795c 100644 --- a/include/linux/i2c-id.h +++ b/include/linux/i2c-id.h | |||
@@ -83,7 +83,6 @@ | |||
83 | #define I2C_DRIVERID_SAA7114 49 /* video decoder */ | 83 | #define I2C_DRIVERID_SAA7114 49 /* video decoder */ |
84 | #define I2C_DRIVERID_ZR36120 50 /* Zoran 36120 video encoder */ | 84 | #define I2C_DRIVERID_ZR36120 50 /* Zoran 36120 video encoder */ |
85 | #define I2C_DRIVERID_24LC32A 51 /* Microchip 24LC32A 32k EEPROM */ | 85 | #define I2C_DRIVERID_24LC32A 51 /* Microchip 24LC32A 32k EEPROM */ |
86 | #define I2C_DRIVERID_STM41T00 52 /* real time clock */ | ||
87 | #define I2C_DRIVERID_UDA1342 53 /* UDA1342 audio codec */ | 86 | #define I2C_DRIVERID_UDA1342 53 /* UDA1342 audio codec */ |
88 | #define I2C_DRIVERID_ADV7170 54 /* video encoder */ | 87 | #define I2C_DRIVERID_ADV7170 54 /* video encoder */ |
89 | #define I2C_DRIVERID_MAX1617 56 /* temp sensor */ | 88 | #define I2C_DRIVERID_MAX1617 56 /* temp sensor */ |
@@ -95,7 +94,6 @@ | |||
95 | #define I2C_DRIVERID_TDA7313 62 /* TDA7313 audio processor */ | 94 | #define I2C_DRIVERID_TDA7313 62 /* TDA7313 audio processor */ |
96 | #define I2C_DRIVERID_MAX6900 63 /* MAX6900 real-time clock */ | 95 | #define I2C_DRIVERID_MAX6900 63 /* MAX6900 real-time clock */ |
97 | #define I2C_DRIVERID_SAA7114H 64 /* video decoder */ | 96 | #define I2C_DRIVERID_SAA7114H 64 /* video decoder */ |
98 | #define I2C_DRIVERID_DS1374 65 /* DS1374 real time clock */ | ||
99 | #define I2C_DRIVERID_TDA9874 66 /* TV sound decoder */ | 97 | #define I2C_DRIVERID_TDA9874 66 /* TV sound decoder */ |
100 | #define I2C_DRIVERID_SAA6752HS 67 /* MPEG2 encoder */ | 98 | #define I2C_DRIVERID_SAA6752HS 67 /* MPEG2 encoder */ |
101 | #define I2C_DRIVERID_TVEEPROM 68 /* TV EEPROM */ | 99 | #define I2C_DRIVERID_TVEEPROM 68 /* TV EEPROM */ |
diff --git a/include/linux/m41t00.h b/include/linux/m41t00.h deleted file mode 100644 index b423360ca38e..000000000000 --- a/include/linux/m41t00.h +++ /dev/null | |||
@@ -1,50 +0,0 @@ | |||
1 | /* | ||
2 | * Definitions for the ST M41T00 family of i2c rtc chips. | ||
3 | * | ||
4 | * Author: Mark A. Greer <mgreer@mvista.com> | ||
5 | * | ||
6 | * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under | ||
7 | * the terms of the GNU General Public License version 2. This program | ||
8 | * is licensed "as is" without any warranty of any kind, whether express | ||
9 | * or implied. | ||
10 | */ | ||
11 | |||
12 | #ifndef _M41T00_H | ||
13 | #define _M41T00_H | ||
14 | |||
15 | #define M41T00_DRV_NAME "m41t00" | ||
16 | #define M41T00_I2C_ADDR 0x68 | ||
17 | |||
18 | #define M41T00_TYPE_M41T00 0 | ||
19 | #define M41T00_TYPE_M41T81 81 | ||
20 | #define M41T00_TYPE_M41T85 85 | ||
21 | |||
22 | struct m41t00_platform_data { | ||
23 | u8 type; | ||
24 | u8 i2c_addr; | ||
25 | u8 sqw_freq; | ||
26 | }; | ||
27 | |||
28 | /* SQW output disabled, this is default value by power on */ | ||
29 | #define M41T00_SQW_DISABLE (0) | ||
30 | |||
31 | #define M41T00_SQW_32KHZ (1<<4) /* 32.768 KHz */ | ||
32 | #define M41T00_SQW_8KHZ (2<<4) /* 8.192 KHz */ | ||
33 | #define M41T00_SQW_4KHZ (3<<4) /* 4.096 KHz */ | ||
34 | #define M41T00_SQW_2KHZ (4<<4) /* 2.048 KHz */ | ||
35 | #define M41T00_SQW_1KHZ (5<<4) /* 1.024 KHz */ | ||
36 | #define M41T00_SQW_512HZ (6<<4) /* 512 Hz */ | ||
37 | #define M41T00_SQW_256HZ (7<<4) /* 256 Hz */ | ||
38 | #define M41T00_SQW_128HZ (8<<4) /* 128 Hz */ | ||
39 | #define M41T00_SQW_64HZ (9<<4) /* 64 Hz */ | ||
40 | #define M41T00_SQW_32HZ (10<<4) /* 32 Hz */ | ||
41 | #define M41T00_SQW_16HZ (11<<4) /* 16 Hz */ | ||
42 | #define M41T00_SQW_8HZ (12<<4) /* 8 Hz */ | ||
43 | #define M41T00_SQW_4HZ (13<<4) /* 4 Hz */ | ||
44 | #define M41T00_SQW_2HZ (14<<4) /* 2 Hz */ | ||
45 | #define M41T00_SQW_1HZ (15<<4) /* 1 Hz */ | ||
46 | |||
47 | extern ulong m41t00_get_rtc_time(void); | ||
48 | extern int m41t00_set_rtc_time(ulong nowtime); | ||
49 | |||
50 | #endif /* _M41T00_H */ | ||