Commit | Line | Data |
---|---|---|
bf4994d7 SW |
1 | /* |
2 | * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C | |
3 | * | |
4 | * Based on code by Randy Vinson <rvinson@mvista.com>, | |
5 | * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>. | |
6 | * | |
920f91e5 | 7 | * Copyright (C) 2014 Rose Technology |
bf4994d7 SW |
8 | * Copyright (C) 2006-2007 Freescale Semiconductor |
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 | * It would be more efficient to use i2c msgs/i2c_transfer directly but, as | |
17 | * recommened in .../Documentation/i2c/writing-clients section | |
18 | * "Sending and receiving", using SMBus level communication is preferred. | |
19 | */ | |
20 | ||
a737e835 JP |
21 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
22 | ||
bf4994d7 SW |
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/workqueue.h> | |
5a0e3ad6 | 30 | #include <linux/slab.h> |
bc96ba74 | 31 | #include <linux/pm.h> |
920f91e5 SA |
32 | #ifdef CONFIG_RTC_DRV_DS1374_WDT |
33 | #include <linux/fs.h> | |
34 | #include <linux/ioctl.h> | |
35 | #include <linux/miscdevice.h> | |
36 | #include <linux/reboot.h> | |
37 | #include <linux/watchdog.h> | |
38 | #endif | |
bf4994d7 SW |
39 | |
40 | #define DS1374_REG_TOD0 0x00 /* Time of Day */ | |
41 | #define DS1374_REG_TOD1 0x01 | |
42 | #define DS1374_REG_TOD2 0x02 | |
43 | #define DS1374_REG_TOD3 0x03 | |
44 | #define DS1374_REG_WDALM0 0x04 /* Watchdog/Alarm */ | |
45 | #define DS1374_REG_WDALM1 0x05 | |
46 | #define DS1374_REG_WDALM2 0x06 | |
47 | #define DS1374_REG_CR 0x07 /* Control */ | |
48 | #define DS1374_REG_CR_AIE 0x01 /* Alarm Int. Enable */ | |
49 | #define DS1374_REG_CR_WDALM 0x20 /* 1=Watchdog, 0=Alarm */ | |
50 | #define DS1374_REG_CR_WACE 0x40 /* WD/Alarm counter enable */ | |
51 | #define DS1374_REG_SR 0x08 /* Status */ | |
52 | #define DS1374_REG_SR_OSF 0x80 /* Oscillator Stop Flag */ | |
53 | #define DS1374_REG_SR_AF 0x01 /* Alarm Flag */ | |
54 | #define DS1374_REG_TCR 0x09 /* Trickle Charge */ | |
55 | ||
3760f736 | 56 | static const struct i2c_device_id ds1374_id[] = { |
f2eb4327 | 57 | { "ds1374", 0 }, |
3760f736 JD |
58 | { } |
59 | }; | |
60 | MODULE_DEVICE_TABLE(i2c, ds1374_id); | |
61 | ||
920f91e5 SA |
62 | #ifdef CONFIG_OF |
63 | static const struct of_device_id ds1374_of_match[] = { | |
64 | { .compatible = "dallas,ds1374" }, | |
65 | { } | |
66 | }; | |
67 | MODULE_DEVICE_TABLE(of, ds1374_of_match); | |
68 | #endif | |
69 | ||
bf4994d7 SW |
70 | struct ds1374 { |
71 | struct i2c_client *client; | |
72 | struct rtc_device *rtc; | |
73 | struct work_struct work; | |
74 | ||
75 | /* The mutex protects alarm operations, and prevents a race | |
76 | * between the enable_irq() in the workqueue and the free_irq() | |
77 | * in the remove function. | |
78 | */ | |
79 | struct mutex mutex; | |
80 | int exiting; | |
81 | }; | |
82 | ||
83 | static struct i2c_driver ds1374_driver; | |
84 | ||
85 | static int ds1374_read_rtc(struct i2c_client *client, u32 *time, | |
adc7b9b6 | 86 | int reg, int nbytes) |
bf4994d7 SW |
87 | { |
88 | u8 buf[4]; | |
89 | int ret; | |
90 | int i; | |
91 | ||
92 | if (nbytes > 4) { | |
93 | WARN_ON(1); | |
94 | return -EINVAL; | |
95 | } | |
96 | ||
97 | ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf); | |
98 | ||
99 | if (ret < 0) | |
100 | return ret; | |
101 | if (ret < nbytes) | |
102 | return -EIO; | |
103 | ||
104 | for (i = nbytes - 1, *time = 0; i >= 0; i--) | |
105 | *time = (*time << 8) | buf[i]; | |
106 | ||
107 | return 0; | |
108 | } | |
109 | ||
110 | static int ds1374_write_rtc(struct i2c_client *client, u32 time, | |
adc7b9b6 | 111 | int reg, int nbytes) |
bf4994d7 SW |
112 | { |
113 | u8 buf[4]; | |
114 | int i; | |
115 | ||
116 | if (nbytes > 4) { | |
117 | WARN_ON(1); | |
118 | return -EINVAL; | |
119 | } | |
120 | ||
121 | for (i = 0; i < nbytes; i++) { | |
122 | buf[i] = time & 0xff; | |
123 | time >>= 8; | |
124 | } | |
125 | ||
126 | return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf); | |
127 | } | |
128 | ||
129 | static int ds1374_check_rtc_status(struct i2c_client *client) | |
130 | { | |
131 | int ret = 0; | |
132 | int control, stat; | |
133 | ||
134 | stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); | |
135 | if (stat < 0) | |
136 | return stat; | |
137 | ||
138 | if (stat & DS1374_REG_SR_OSF) | |
139 | dev_warn(&client->dev, | |
adc7b9b6 | 140 | "oscillator discontinuity flagged, time unreliable\n"); |
bf4994d7 SW |
141 | |
142 | stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF); | |
143 | ||
144 | ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); | |
145 | if (ret < 0) | |
146 | return ret; | |
147 | ||
148 | /* If the alarm is pending, clear it before requesting | |
149 | * the interrupt, so an interrupt event isn't reported | |
150 | * before everything is initialized. | |
151 | */ | |
152 | ||
153 | control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); | |
154 | if (control < 0) | |
155 | return control; | |
156 | ||
157 | control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); | |
158 | return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); | |
159 | } | |
160 | ||
161 | static int ds1374_read_time(struct device *dev, struct rtc_time *time) | |
162 | { | |
163 | struct i2c_client *client = to_i2c_client(dev); | |
164 | u32 itime; | |
165 | int ret; | |
166 | ||
167 | ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4); | |
168 | if (!ret) | |
169 | rtc_time_to_tm(itime, time); | |
170 | ||
171 | return ret; | |
172 | } | |
173 | ||
174 | static int ds1374_set_time(struct device *dev, struct rtc_time *time) | |
175 | { | |
176 | struct i2c_client *client = to_i2c_client(dev); | |
177 | unsigned long itime; | |
178 | ||
179 | rtc_tm_to_time(time, &itime); | |
180 | return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4); | |
181 | } | |
182 | ||
920f91e5 | 183 | #ifndef CONFIG_RTC_DRV_DS1374_WDT |
bf4994d7 SW |
184 | /* The ds1374 has a decrementer for an alarm, rather than a comparator. |
185 | * If the time of day is changed, then the alarm will need to be | |
186 | * reset. | |
187 | */ | |
188 | static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
189 | { | |
190 | struct i2c_client *client = to_i2c_client(dev); | |
191 | struct ds1374 *ds1374 = i2c_get_clientdata(client); | |
192 | u32 now, cur_alarm; | |
193 | int cr, sr; | |
194 | int ret = 0; | |
195 | ||
b42f9317 | 196 | if (client->irq <= 0) |
bf4994d7 SW |
197 | return -EINVAL; |
198 | ||
199 | mutex_lock(&ds1374->mutex); | |
200 | ||
201 | cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); | |
202 | if (ret < 0) | |
203 | goto out; | |
204 | ||
205 | sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR); | |
206 | if (ret < 0) | |
207 | goto out; | |
208 | ||
209 | ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4); | |
210 | if (ret) | |
211 | goto out; | |
212 | ||
213 | ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3); | |
214 | if (ret) | |
215 | goto out; | |
216 | ||
217 | rtc_time_to_tm(now + cur_alarm, &alarm->time); | |
218 | alarm->enabled = !!(cr & DS1374_REG_CR_WACE); | |
219 | alarm->pending = !!(sr & DS1374_REG_SR_AF); | |
220 | ||
221 | out: | |
222 | mutex_unlock(&ds1374->mutex); | |
223 | return ret; | |
224 | } | |
225 | ||
226 | static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
227 | { | |
228 | struct i2c_client *client = to_i2c_client(dev); | |
229 | struct ds1374 *ds1374 = i2c_get_clientdata(client); | |
230 | struct rtc_time now; | |
231 | unsigned long new_alarm, itime; | |
232 | int cr; | |
233 | int ret = 0; | |
234 | ||
b42f9317 | 235 | if (client->irq <= 0) |
bf4994d7 SW |
236 | return -EINVAL; |
237 | ||
238 | ret = ds1374_read_time(dev, &now); | |
239 | if (ret < 0) | |
240 | return ret; | |
241 | ||
242 | rtc_tm_to_time(&alarm->time, &new_alarm); | |
243 | rtc_tm_to_time(&now, &itime); | |
244 | ||
bf4994d7 SW |
245 | /* This can happen due to races, in addition to dates that are |
246 | * truly in the past. To avoid requiring the caller to check for | |
247 | * races, dates in the past are assumed to be in the recent past | |
248 | * (i.e. not something that we'd rather the caller know about via | |
249 | * an error), and the alarm is set to go off as soon as possible. | |
250 | */ | |
fa7af8b1 | 251 | if (time_before_eq(new_alarm, itime)) |
bf4994d7 | 252 | new_alarm = 1; |
fa7af8b1 RK |
253 | else |
254 | new_alarm -= itime; | |
bf4994d7 SW |
255 | |
256 | mutex_lock(&ds1374->mutex); | |
257 | ||
258 | ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR); | |
259 | if (ret < 0) | |
260 | goto out; | |
261 | ||
262 | /* Disable any existing alarm before setting the new one | |
263 | * (or lack thereof). */ | |
264 | cr &= ~DS1374_REG_CR_WACE; | |
265 | ||
266 | ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); | |
267 | if (ret < 0) | |
268 | goto out; | |
269 | ||
270 | ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3); | |
271 | if (ret) | |
272 | goto out; | |
273 | ||
274 | if (alarm->enabled) { | |
275 | cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; | |
276 | cr &= ~DS1374_REG_CR_WDALM; | |
277 | ||
278 | ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); | |
279 | } | |
280 | ||
281 | out: | |
282 | mutex_unlock(&ds1374->mutex); | |
283 | return ret; | |
284 | } | |
920f91e5 | 285 | #endif |
bf4994d7 SW |
286 | |
287 | static irqreturn_t ds1374_irq(int irq, void *dev_id) | |
288 | { | |
289 | struct i2c_client *client = dev_id; | |
290 | struct ds1374 *ds1374 = i2c_get_clientdata(client); | |
291 | ||
292 | disable_irq_nosync(irq); | |
293 | schedule_work(&ds1374->work); | |
294 | return IRQ_HANDLED; | |
295 | } | |
296 | ||
297 | static void ds1374_work(struct work_struct *work) | |
298 | { | |
299 | struct ds1374 *ds1374 = container_of(work, struct ds1374, work); | |
300 | struct i2c_client *client = ds1374->client; | |
301 | int stat, control; | |
302 | ||
303 | mutex_lock(&ds1374->mutex); | |
304 | ||
305 | stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); | |
306 | if (stat < 0) | |
28df30e6 | 307 | goto unlock; |
bf4994d7 SW |
308 | |
309 | if (stat & DS1374_REG_SR_AF) { | |
310 | stat &= ~DS1374_REG_SR_AF; | |
311 | i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); | |
312 | ||
313 | control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); | |
314 | if (control < 0) | |
315 | goto out; | |
316 | ||
317 | control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); | |
318 | i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); | |
319 | ||
bf4994d7 | 320 | rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF); |
bf4994d7 SW |
321 | } |
322 | ||
323 | out: | |
324 | if (!ds1374->exiting) | |
325 | enable_irq(client->irq); | |
28df30e6 | 326 | unlock: |
bf4994d7 SW |
327 | mutex_unlock(&ds1374->mutex); |
328 | } | |
329 | ||
920f91e5 | 330 | #ifndef CONFIG_RTC_DRV_DS1374_WDT |
16380c15 | 331 | static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled) |
bf4994d7 SW |
332 | { |
333 | struct i2c_client *client = to_i2c_client(dev); | |
334 | struct ds1374 *ds1374 = i2c_get_clientdata(client); | |
16380c15 | 335 | int ret; |
bf4994d7 SW |
336 | |
337 | mutex_lock(&ds1374->mutex); | |
338 | ||
16380c15 JS |
339 | ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); |
340 | if (ret < 0) | |
341 | goto out; | |
bf4994d7 | 342 | |
16380c15 | 343 | if (enabled) { |
bf4994d7 SW |
344 | ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; |
345 | ret &= ~DS1374_REG_CR_WDALM; | |
16380c15 JS |
346 | } else { |
347 | ret &= ~DS1374_REG_CR_WACE; | |
bf4994d7 | 348 | } |
16380c15 | 349 | ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); |
bf4994d7 SW |
350 | |
351 | out: | |
352 | mutex_unlock(&ds1374->mutex); | |
353 | return ret; | |
354 | } | |
920f91e5 | 355 | #endif |
bf4994d7 SW |
356 | |
357 | static const struct rtc_class_ops ds1374_rtc_ops = { | |
358 | .read_time = ds1374_read_time, | |
359 | .set_time = ds1374_set_time, | |
920f91e5 | 360 | #ifndef CONFIG_RTC_DRV_DS1374_WDT |
bf4994d7 SW |
361 | .read_alarm = ds1374_read_alarm, |
362 | .set_alarm = ds1374_set_alarm, | |
16380c15 | 363 | .alarm_irq_enable = ds1374_alarm_irq_enable, |
920f91e5 SA |
364 | #endif |
365 | }; | |
366 | ||
367 | #ifdef CONFIG_RTC_DRV_DS1374_WDT | |
368 | /* | |
369 | ***************************************************************************** | |
370 | * | |
371 | * Watchdog Driver | |
372 | * | |
373 | ***************************************************************************** | |
374 | */ | |
375 | static struct i2c_client *save_client; | |
376 | /* Default margin */ | |
377 | #define WD_TIMO 131762 | |
378 | ||
379 | #define DRV_NAME "DS1374 Watchdog" | |
380 | ||
381 | static int wdt_margin = WD_TIMO; | |
382 | static unsigned long wdt_is_open; | |
383 | module_param(wdt_margin, int, 0); | |
384 | MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)"); | |
385 | ||
386 | static const struct watchdog_info ds1374_wdt_info = { | |
387 | .identity = "DS1374 WTD", | |
388 | .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | | |
389 | WDIOF_MAGICCLOSE, | |
390 | }; | |
391 | ||
392 | static int ds1374_wdt_settimeout(unsigned int timeout) | |
393 | { | |
394 | int ret = -ENOIOCTLCMD; | |
395 | int cr; | |
396 | ||
397 | ret = cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR); | |
398 | if (ret < 0) | |
399 | goto out; | |
400 | ||
401 | /* Disable any existing watchdog/alarm before setting the new one */ | |
402 | cr &= ~DS1374_REG_CR_WACE; | |
403 | ||
404 | ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); | |
405 | if (ret < 0) | |
406 | goto out; | |
407 | ||
408 | /* Set new watchdog time */ | |
409 | ret = ds1374_write_rtc(save_client, timeout, DS1374_REG_WDALM0, 3); | |
410 | if (ret) { | |
a737e835 | 411 | pr_info("couldn't set new watchdog time\n"); |
920f91e5 SA |
412 | goto out; |
413 | } | |
414 | ||
415 | /* Enable watchdog timer */ | |
416 | cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM; | |
417 | cr &= ~DS1374_REG_CR_AIE; | |
418 | ||
419 | ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); | |
420 | if (ret < 0) | |
421 | goto out; | |
422 | ||
423 | return 0; | |
424 | out: | |
425 | return ret; | |
426 | } | |
427 | ||
428 | ||
429 | /* | |
430 | * Reload the watchdog timer. (ie, pat the watchdog) | |
431 | */ | |
432 | static void ds1374_wdt_ping(void) | |
433 | { | |
434 | u32 val; | |
435 | int ret = 0; | |
436 | ||
437 | ret = ds1374_read_rtc(save_client, &val, DS1374_REG_WDALM0, 3); | |
438 | if (ret) | |
439 | pr_info("WD TICK FAIL!!!!!!!!!! %i\n", ret); | |
440 | } | |
441 | ||
442 | static void ds1374_wdt_disable(void) | |
443 | { | |
444 | int ret = -ENOIOCTLCMD; | |
445 | int cr; | |
446 | ||
447 | cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR); | |
448 | /* Disable watchdog timer */ | |
449 | cr &= ~DS1374_REG_CR_WACE; | |
450 | ||
451 | ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr); | |
452 | } | |
453 | ||
454 | /* | |
455 | * Watchdog device is opened, and watchdog starts running. | |
456 | */ | |
457 | static int ds1374_wdt_open(struct inode *inode, struct file *file) | |
458 | { | |
459 | struct ds1374 *ds1374 = i2c_get_clientdata(save_client); | |
460 | ||
461 | if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) { | |
462 | mutex_lock(&ds1374->mutex); | |
463 | if (test_and_set_bit(0, &wdt_is_open)) { | |
464 | mutex_unlock(&ds1374->mutex); | |
465 | return -EBUSY; | |
466 | } | |
467 | /* | |
468 | * Activate | |
469 | */ | |
470 | wdt_is_open = 1; | |
471 | mutex_unlock(&ds1374->mutex); | |
472 | return nonseekable_open(inode, file); | |
473 | } | |
474 | return -ENODEV; | |
475 | } | |
476 | ||
477 | /* | |
478 | * Close the watchdog device. | |
479 | */ | |
480 | static int ds1374_wdt_release(struct inode *inode, struct file *file) | |
481 | { | |
482 | if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) | |
483 | clear_bit(0, &wdt_is_open); | |
484 | ||
485 | return 0; | |
486 | } | |
487 | ||
488 | /* | |
489 | * Pat the watchdog whenever device is written to. | |
490 | */ | |
491 | static ssize_t ds1374_wdt_write(struct file *file, const char __user *data, | |
492 | size_t len, loff_t *ppos) | |
493 | { | |
494 | if (len) { | |
495 | ds1374_wdt_ping(); | |
496 | return 1; | |
497 | } | |
498 | return 0; | |
499 | } | |
500 | ||
501 | static ssize_t ds1374_wdt_read(struct file *file, char __user *data, | |
502 | size_t len, loff_t *ppos) | |
503 | { | |
504 | return 0; | |
505 | } | |
506 | ||
507 | /* | |
508 | * Handle commands from user-space. | |
509 | */ | |
510 | static long ds1374_wdt_ioctl(struct file *file, unsigned int cmd, | |
511 | unsigned long arg) | |
512 | { | |
513 | int new_margin, options; | |
514 | ||
515 | switch (cmd) { | |
516 | case WDIOC_GETSUPPORT: | |
517 | return copy_to_user((struct watchdog_info __user *)arg, | |
518 | &ds1374_wdt_info, sizeof(ds1374_wdt_info)) ? -EFAULT : 0; | |
519 | ||
520 | case WDIOC_GETSTATUS: | |
521 | case WDIOC_GETBOOTSTATUS: | |
522 | return put_user(0, (int __user *)arg); | |
523 | case WDIOC_KEEPALIVE: | |
524 | ds1374_wdt_ping(); | |
525 | return 0; | |
526 | case WDIOC_SETTIMEOUT: | |
527 | if (get_user(new_margin, (int __user *)arg)) | |
528 | return -EFAULT; | |
529 | ||
530 | if (new_margin < 1 || new_margin > 16777216) | |
531 | return -EINVAL; | |
532 | ||
533 | wdt_margin = new_margin; | |
534 | ds1374_wdt_settimeout(new_margin); | |
535 | ds1374_wdt_ping(); | |
536 | /* fallthrough */ | |
537 | case WDIOC_GETTIMEOUT: | |
538 | return put_user(wdt_margin, (int __user *)arg); | |
539 | case WDIOC_SETOPTIONS: | |
540 | if (copy_from_user(&options, (int __user *)arg, sizeof(int))) | |
541 | return -EFAULT; | |
542 | ||
543 | if (options & WDIOS_DISABLECARD) { | |
a737e835 | 544 | pr_info("disable watchdog\n"); |
920f91e5 SA |
545 | ds1374_wdt_disable(); |
546 | } | |
547 | ||
548 | if (options & WDIOS_ENABLECARD) { | |
a737e835 | 549 | pr_info("enable watchdog\n"); |
920f91e5 SA |
550 | ds1374_wdt_settimeout(wdt_margin); |
551 | ds1374_wdt_ping(); | |
552 | } | |
553 | ||
554 | return -EINVAL; | |
555 | } | |
556 | return -ENOTTY; | |
557 | } | |
558 | ||
559 | static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd, | |
560 | unsigned long arg) | |
561 | { | |
562 | int ret; | |
563 | struct ds1374 *ds1374 = i2c_get_clientdata(save_client); | |
564 | ||
565 | mutex_lock(&ds1374->mutex); | |
566 | ret = ds1374_wdt_ioctl(file, cmd, arg); | |
567 | mutex_unlock(&ds1374->mutex); | |
568 | ||
569 | return ret; | |
570 | } | |
571 | ||
572 | static int ds1374_wdt_notify_sys(struct notifier_block *this, | |
573 | unsigned long code, void *unused) | |
574 | { | |
575 | if (code == SYS_DOWN || code == SYS_HALT) | |
576 | /* Disable Watchdog */ | |
577 | ds1374_wdt_disable(); | |
578 | return NOTIFY_DONE; | |
579 | } | |
580 | ||
581 | static const struct file_operations ds1374_wdt_fops = { | |
582 | .owner = THIS_MODULE, | |
583 | .read = ds1374_wdt_read, | |
584 | .unlocked_ioctl = ds1374_wdt_unlocked_ioctl, | |
585 | .write = ds1374_wdt_write, | |
586 | .open = ds1374_wdt_open, | |
587 | .release = ds1374_wdt_release, | |
588 | .llseek = no_llseek, | |
589 | }; | |
590 | ||
591 | static struct miscdevice ds1374_miscdev = { | |
592 | .minor = WATCHDOG_MINOR, | |
593 | .name = "watchdog", | |
594 | .fops = &ds1374_wdt_fops, | |
bf4994d7 SW |
595 | }; |
596 | ||
920f91e5 SA |
597 | static struct notifier_block ds1374_wdt_notifier = { |
598 | .notifier_call = ds1374_wdt_notify_sys, | |
599 | }; | |
600 | ||
601 | #endif /*CONFIG_RTC_DRV_DS1374_WDT*/ | |
602 | /* | |
603 | ***************************************************************************** | |
604 | * | |
605 | * Driver Interface | |
606 | * | |
607 | ***************************************************************************** | |
608 | */ | |
d2653e92 JD |
609 | static int ds1374_probe(struct i2c_client *client, |
610 | const struct i2c_device_id *id) | |
bf4994d7 SW |
611 | { |
612 | struct ds1374 *ds1374; | |
613 | int ret; | |
614 | ||
d1a96639 | 615 | ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL); |
bf4994d7 SW |
616 | if (!ds1374) |
617 | return -ENOMEM; | |
618 | ||
619 | ds1374->client = client; | |
620 | i2c_set_clientdata(client, ds1374); | |
621 | ||
622 | INIT_WORK(&ds1374->work, ds1374_work); | |
623 | mutex_init(&ds1374->mutex); | |
624 | ||
625 | ret = ds1374_check_rtc_status(client); | |
626 | if (ret) | |
d1a96639 | 627 | return ret; |
bf4994d7 | 628 | |
b42f9317 | 629 | if (client->irq > 0) { |
d1a96639 | 630 | ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0, |
adc7b9b6 | 631 | "ds1374", client); |
bf4994d7 SW |
632 | if (ret) { |
633 | dev_err(&client->dev, "unable to request IRQ\n"); | |
d1a96639 | 634 | return ret; |
bf4994d7 | 635 | } |
26b3c01f AV |
636 | |
637 | device_set_wakeup_capable(&client->dev, 1); | |
bf4994d7 SW |
638 | } |
639 | ||
d1a96639 | 640 | ds1374->rtc = devm_rtc_device_register(&client->dev, client->name, |
adc7b9b6 | 641 | &ds1374_rtc_ops, THIS_MODULE); |
bf4994d7 | 642 | if (IS_ERR(ds1374->rtc)) { |
bf4994d7 | 643 | dev_err(&client->dev, "unable to register the class device\n"); |
d1a96639 | 644 | return PTR_ERR(ds1374->rtc); |
bf4994d7 SW |
645 | } |
646 | ||
920f91e5 SA |
647 | #ifdef CONFIG_RTC_DRV_DS1374_WDT |
648 | save_client = client; | |
649 | ret = misc_register(&ds1374_miscdev); | |
650 | if (ret) | |
651 | return ret; | |
652 | ret = register_reboot_notifier(&ds1374_wdt_notifier); | |
653 | if (ret) { | |
654 | misc_deregister(&ds1374_miscdev); | |
655 | return ret; | |
656 | } | |
657 | ds1374_wdt_settimeout(131072); | |
658 | #endif | |
659 | ||
bf4994d7 | 660 | return 0; |
bf4994d7 SW |
661 | } |
662 | ||
5a167f45 | 663 | static int ds1374_remove(struct i2c_client *client) |
bf4994d7 SW |
664 | { |
665 | struct ds1374 *ds1374 = i2c_get_clientdata(client); | |
920f91e5 SA |
666 | #ifdef CONFIG_RTC_DRV_DS1374_WDT |
667 | int res; | |
668 | ||
f368ed60 GKH |
669 | misc_deregister(&ds1374_miscdev); |
670 | ds1374_miscdev.parent = NULL; | |
920f91e5 SA |
671 | unregister_reboot_notifier(&ds1374_wdt_notifier); |
672 | #endif | |
bf4994d7 | 673 | |
b42f9317 | 674 | if (client->irq > 0) { |
bf4994d7 SW |
675 | mutex_lock(&ds1374->mutex); |
676 | ds1374->exiting = 1; | |
677 | mutex_unlock(&ds1374->mutex); | |
678 | ||
d1a96639 | 679 | devm_free_irq(&client->dev, client->irq, client); |
9db8995b | 680 | cancel_work_sync(&ds1374->work); |
bf4994d7 SW |
681 | } |
682 | ||
bf4994d7 SW |
683 | return 0; |
684 | } | |
685 | ||
8b80ef64 | 686 | #ifdef CONFIG_PM_SLEEP |
bc96ba74 | 687 | static int ds1374_suspend(struct device *dev) |
986e36a5 | 688 | { |
bc96ba74 MB |
689 | struct i2c_client *client = to_i2c_client(dev); |
690 | ||
986e36a5 MP |
691 | if (client->irq >= 0 && device_may_wakeup(&client->dev)) |
692 | enable_irq_wake(client->irq); | |
693 | return 0; | |
694 | } | |
695 | ||
bc96ba74 | 696 | static int ds1374_resume(struct device *dev) |
986e36a5 | 697 | { |
bc96ba74 MB |
698 | struct i2c_client *client = to_i2c_client(dev); |
699 | ||
986e36a5 MP |
700 | if (client->irq >= 0 && device_may_wakeup(&client->dev)) |
701 | disable_irq_wake(client->irq); | |
702 | return 0; | |
703 | } | |
8b80ef64 | 704 | #endif |
bc96ba74 MB |
705 | |
706 | static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume); | |
707 | ||
bf4994d7 SW |
708 | static struct i2c_driver ds1374_driver = { |
709 | .driver = { | |
710 | .name = "rtc-ds1374", | |
711 | .owner = THIS_MODULE, | |
8b80ef64 | 712 | .pm = &ds1374_pm, |
bf4994d7 SW |
713 | }, |
714 | .probe = ds1374_probe, | |
5a167f45 | 715 | .remove = ds1374_remove, |
3760f736 | 716 | .id_table = ds1374_id, |
bf4994d7 SW |
717 | }; |
718 | ||
0abc9201 | 719 | module_i2c_driver(ds1374_driver); |
bf4994d7 SW |
720 | |
721 | MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>"); | |
722 | MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver"); | |
723 | MODULE_LICENSE("GPL"); |